/*!
 * ONNX Runtime Web v1.26.0
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License.
 */
"use strict";
var ort = (() => {
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
  }) : x)(function(x) {
    if (typeof require !== "undefined") return require.apply(this, arguments);
    throw Error('Dynamic require of "' + x + '" is not supported');
  });
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

  // common/dist/esm/backend-impl.js
  var backends, backendsSortedByPriority, registerBackend, tryResolveAndInitializeBackend, resolveBackendAndExecutionProviders;
  var init_backend_impl = __esm({
    "common/dist/esm/backend-impl.js"() {
      "use strict";
      backends = /* @__PURE__ */ new Map();
      backendsSortedByPriority = [];
      registerBackend = (name, backend, priority) => {
        if (backend && typeof backend.init === "function" && typeof backend.createInferenceSessionHandler === "function") {
          const currentBackend = backends.get(name);
          if (currentBackend === void 0) {
            backends.set(name, { backend, priority });
          } else if (currentBackend.priority > priority) {
            return;
          } else if (currentBackend.priority === priority) {
            if (currentBackend.backend !== backend) {
              throw new Error(`cannot register backend "${name}" using priority ${priority}`);
            }
          }
          if (priority >= 0) {
            const i = backendsSortedByPriority.indexOf(name);
            if (i !== -1) {
              backendsSortedByPriority.splice(i, 1);
            }
            for (let i2 = 0; i2 < backendsSortedByPriority.length; i2++) {
              if (backends.get(backendsSortedByPriority[i2]).priority <= priority) {
                backendsSortedByPriority.splice(i2, 0, name);
                return;
              }
            }
            backendsSortedByPriority.push(name);
          }
          return;
        }
        throw new TypeError("not a valid backend");
      };
      tryResolveAndInitializeBackend = async (backendName) => {
        const backendInfo = backends.get(backendName);
        if (!backendInfo) {
          return "backend not found.";
        }
        if (backendInfo.initialized) {
          return backendInfo.backend;
        } else if (backendInfo.aborted) {
          return backendInfo.error;
        } else {
          const isInitializing = !!backendInfo.initPromise;
          try {
            if (!isInitializing) {
              backendInfo.initPromise = backendInfo.backend.init(backendName);
            }
            await backendInfo.initPromise;
            backendInfo.initialized = true;
            return backendInfo.backend;
          } catch (e) {
            if (!isInitializing) {
              backendInfo.error = `${e}`;
              backendInfo.aborted = true;
            }
            return backendInfo.error;
          } finally {
            delete backendInfo.initPromise;
          }
        }
      };
      resolveBackendAndExecutionProviders = async (options) => {
        const eps = options.executionProviders || [];
        const backendHints = eps.map((i) => typeof i === "string" ? i : i.name);
        const backendNames = backendHints.length === 0 ? backendsSortedByPriority : backendHints;
        let backend;
        const errors = [];
        const availableBackendNames = /* @__PURE__ */ new Set();
        for (const backendName of backendNames) {
          const resolveResult = await tryResolveAndInitializeBackend(backendName);
          if (typeof resolveResult === "string") {
            errors.push({ name: backendName, err: resolveResult });
          } else {
            if (!backend) {
              backend = resolveResult;
            }
            if (backend === resolveResult) {
              availableBackendNames.add(backendName);
            }
          }
        }
        if (!backend) {
          throw new Error(`no available backend found. ERR: ${errors.map((e) => `[${e.name}] ${e.err}`).join(", ")}`);
        }
        for (const { name, err } of errors) {
          if (backendHints.includes(name)) {
            console.warn(`removing requested execution provider "${name}" from session options because it is not available: ${err}`);
          }
        }
        const filteredEps = eps.filter((i) => availableBackendNames.has(typeof i === "string" ? i : i.name));
        return [
          backend,
          new Proxy(options, {
            get: (target, prop) => {
              if (prop === "executionProviders") {
                return filteredEps;
              }
              return Reflect.get(target, prop);
            }
          })
        ];
      };
    }
  });

  // common/dist/esm/backend.js
  var init_backend = __esm({
    "common/dist/esm/backend.js"() {
      "use strict";
      init_backend_impl();
    }
  });

  // common/dist/esm/version.js
  var version;
  var init_version = __esm({
    "common/dist/esm/version.js"() {
      "use strict";
      version = "1.26.0";
    }
  });

  // common/dist/esm/env-impl.js
  var logLevelValue, env;
  var init_env_impl = __esm({
    "common/dist/esm/env-impl.js"() {
      "use strict";
      init_version();
      logLevelValue = "warning";
      env = {
        wasm: {},
        webgl: {},
        webgpu: {},
        versions: { common: version },
        set logLevel(value) {
          if (value === void 0) {
            return;
          }
          if (typeof value !== "string" || ["verbose", "info", "warning", "error", "fatal"].indexOf(value) === -1) {
            throw new Error(`Unsupported logging level: ${value}`);
          }
          logLevelValue = value;
        },
        get logLevel() {
          return logLevelValue;
        }
      };
      Object.defineProperty(env, "logLevel", { enumerable: true });
    }
  });

  // common/dist/esm/env.js
  var env2;
  var init_env = __esm({
    "common/dist/esm/env.js"() {
      "use strict";
      init_env_impl();
      env2 = env;
    }
  });

  // common/dist/esm/tensor-conversion-impl.js
  var tensorToDataURL, tensorToImageData;
  var init_tensor_conversion_impl = __esm({
    "common/dist/esm/tensor-conversion-impl.js"() {
      "use strict";
      tensorToDataURL = (tensor, options) => {
        const canvas = typeof document !== "undefined" ? document.createElement("canvas") : new OffscreenCanvas(1, 1);
        canvas.width = tensor.dims[3];
        canvas.height = tensor.dims[2];
        const pixels2DContext = canvas.getContext("2d");
        if (pixels2DContext != null) {
          let width;
          let height;
          if (options?.tensorLayout !== void 0 && options.tensorLayout === "NHWC") {
            width = tensor.dims[2];
            height = tensor.dims[3];
          } else {
            width = tensor.dims[3];
            height = tensor.dims[2];
          }
          const inputformat = options?.format !== void 0 ? options.format : "RGB";
          const norm = options?.norm;
          let normMean;
          let normBias;
          if (norm === void 0 || norm.mean === void 0) {
            normMean = [255, 255, 255, 255];
          } else {
            if (typeof norm.mean === "number") {
              normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
            } else {
              normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 0];
              if (norm.mean[3] !== void 0) {
                normMean[3] = norm.mean[3];
              }
            }
          }
          if (norm === void 0 || norm.bias === void 0) {
            normBias = [0, 0, 0, 0];
          } else {
            if (typeof norm.bias === "number") {
              normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
            } else {
              normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];
              if (norm.bias[3] !== void 0) {
                normBias[3] = norm.bias[3];
              }
            }
          }
          const stride = height * width;
          let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
          if (inputformat === "RGBA") {
            rTensorPointer = 0;
            gTensorPointer = stride;
            bTensorPointer = stride * 2;
            aTensorPointer = stride * 3;
          } else if (inputformat === "RGB") {
            rTensorPointer = 0;
            gTensorPointer = stride;
            bTensorPointer = stride * 2;
          } else if (inputformat === "RBG") {
            rTensorPointer = 0;
            bTensorPointer = stride;
            gTensorPointer = stride * 2;
          }
          for (let i = 0; i < height; i++) {
            for (let j = 0; j < width; j++) {
              const R = (tensor.data[rTensorPointer++] - normBias[0]) * normMean[0];
              const G = (tensor.data[gTensorPointer++] - normBias[1]) * normMean[1];
              const B = (tensor.data[bTensorPointer++] - normBias[2]) * normMean[2];
              const A = aTensorPointer === -1 ? 255 : (tensor.data[aTensorPointer++] - normBias[3]) * normMean[3];
              pixels2DContext.fillStyle = "rgba(" + R + "," + G + "," + B + "," + A + ")";
              pixels2DContext.fillRect(j, i, 1, 1);
            }
          }
          if ("toDataURL" in canvas) {
            return canvas.toDataURL();
          } else {
            throw new Error("toDataURL is not supported");
          }
        } else {
          throw new Error("Can not access image data");
        }
      };
      tensorToImageData = (tensor, options) => {
        const pixels2DContext = typeof document !== "undefined" ? document.createElement("canvas").getContext("2d") : new OffscreenCanvas(1, 1).getContext("2d");
        let image;
        if (pixels2DContext != null) {
          let width;
          let height;
          let channels;
          if (options?.tensorLayout !== void 0 && options.tensorLayout === "NHWC") {
            width = tensor.dims[2];
            height = tensor.dims[1];
            channels = tensor.dims[3];
          } else {
            width = tensor.dims[3];
            height = tensor.dims[2];
            channels = tensor.dims[1];
          }
          const inputformat = options !== void 0 ? options.format !== void 0 ? options.format : "RGB" : "RGB";
          const norm = options?.norm;
          let normMean;
          let normBias;
          if (norm === void 0 || norm.mean === void 0) {
            normMean = [255, 255, 255, 255];
          } else {
            if (typeof norm.mean === "number") {
              normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
            } else {
              normMean = [norm.mean[0], norm.mean[1], norm.mean[2], 255];
              if (norm.mean[3] !== void 0) {
                normMean[3] = norm.mean[3];
              }
            }
          }
          if (norm === void 0 || norm.bias === void 0) {
            normBias = [0, 0, 0, 0];
          } else {
            if (typeof norm.bias === "number") {
              normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
            } else {
              normBias = [norm.bias[0], norm.bias[1], norm.bias[2], 0];
              if (norm.bias[3] !== void 0) {
                normBias[3] = norm.bias[3];
              }
            }
          }
          const stride = height * width;
          if (options !== void 0) {
            if (options.format !== void 0 && channels === 4 && options.format !== "RGBA" || channels === 3 && options.format !== "RGB" && options.format !== "BGR") {
              throw new Error("Tensor format doesn't match input tensor dims");
            }
          }
          const step = 4;
          let rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
          let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
          if (inputformat === "RGBA") {
            rTensorPointer = 0;
            gTensorPointer = stride;
            bTensorPointer = stride * 2;
            aTensorPointer = stride * 3;
          } else if (inputformat === "RGB") {
            rTensorPointer = 0;
            gTensorPointer = stride;
            bTensorPointer = stride * 2;
          } else if (inputformat === "RBG") {
            rTensorPointer = 0;
            bTensorPointer = stride;
            gTensorPointer = stride * 2;
          }
          image = pixels2DContext.createImageData(width, height);
          for (let i = 0; i < height * width; rImagePointer += step, gImagePointer += step, bImagePointer += step, aImagePointer += step, i++) {
            image.data[rImagePointer] = (tensor.data[rTensorPointer++] - normBias[0]) * normMean[0];
            image.data[gImagePointer] = (tensor.data[gTensorPointer++] - normBias[1]) * normMean[1];
            image.data[bImagePointer] = (tensor.data[bTensorPointer++] - normBias[2]) * normMean[2];
            image.data[aImagePointer] = aTensorPointer === -1 ? 255 : (tensor.data[aTensorPointer++] - normBias[3]) * normMean[3];
          }
        } else {
          throw new Error("Can not access image data");
        }
        return image;
      };
    }
  });

  // common/dist/esm/tensor-factory-impl.js
  var bufferToTensor, tensorFromImage, tensorFromTexture, tensorFromGpuBuffer, tensorFromMLTensor, tensorFromPinnedBuffer;
  var init_tensor_factory_impl = __esm({
    "common/dist/esm/tensor-factory-impl.js"() {
      "use strict";
      init_tensor_impl();
      bufferToTensor = (buffer, options) => {
        if (buffer === void 0) {
          throw new Error("Image buffer must be defined");
        }
        if (options.height === void 0 || options.width === void 0) {
          throw new Error("Image height and width must be defined");
        }
        if (options.tensorLayout === "NHWC") {
          throw new Error("NHWC Tensor layout is not supported yet");
        }
        const { height, width } = options;
        const norm = options.norm ?? { mean: 255, bias: 0 };
        let normMean;
        let normBias;
        if (typeof norm.mean === "number") {
          normMean = [norm.mean, norm.mean, norm.mean, norm.mean];
        } else {
          normMean = [norm.mean[0], norm.mean[1], norm.mean[2], norm.mean[3] ?? 255];
        }
        if (typeof norm.bias === "number") {
          normBias = [norm.bias, norm.bias, norm.bias, norm.bias];
        } else {
          normBias = [norm.bias[0], norm.bias[1], norm.bias[2], norm.bias[3] ?? 0];
        }
        const inputformat = options.format !== void 0 ? options.format : "RGBA";
        const outputformat = options.tensorFormat !== void 0 ? options.tensorFormat !== void 0 ? options.tensorFormat : "RGB" : "RGB";
        const stride = height * width;
        const float32Data = outputformat === "RGBA" ? new Float32Array(stride * 4) : new Float32Array(stride * 3);
        let step = 4, rImagePointer = 0, gImagePointer = 1, bImagePointer = 2, aImagePointer = 3;
        let rTensorPointer = 0, gTensorPointer = stride, bTensorPointer = stride * 2, aTensorPointer = -1;
        if (inputformat === "RGB") {
          step = 3;
          rImagePointer = 0;
          gImagePointer = 1;
          bImagePointer = 2;
          aImagePointer = -1;
        }
        if (outputformat === "RGBA") {
          aTensorPointer = stride * 3;
        } else if (outputformat === "RBG") {
          rTensorPointer = 0;
          bTensorPointer = stride;
          gTensorPointer = stride * 2;
        } else if (outputformat === "BGR") {
          bTensorPointer = 0;
          gTensorPointer = stride;
          rTensorPointer = stride * 2;
        }
        for (let i = 0; i < stride; i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step) {
          float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias[0]) / normMean[0];
          float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias[1]) / normMean[1];
          float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias[2]) / normMean[2];
          if (aTensorPointer !== -1 && aImagePointer !== -1) {
            float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias[3]) / normMean[3];
          }
        }
        const outputTensor = outputformat === "RGBA" ? new Tensor("float32", float32Data, [1, 4, height, width]) : new Tensor("float32", float32Data, [1, 3, height, width]);
        return outputTensor;
      };
      tensorFromImage = async (image, options) => {
        const isHTMLImageEle = typeof HTMLImageElement !== "undefined" && image instanceof HTMLImageElement;
        const isImageDataEle = typeof ImageData !== "undefined" && image instanceof ImageData;
        const isImageBitmap = typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap;
        const isString = typeof image === "string";
        let data;
        let bufferToTensorOptions = options ?? {};
        const createCanvas = () => {
          if (typeof document !== "undefined") {
            return document.createElement("canvas");
          } else if (typeof OffscreenCanvas !== "undefined") {
            return new OffscreenCanvas(1, 1);
          } else {
            throw new Error("Canvas is not supported");
          }
        };
        const createCanvasContext = (canvas) => {
          if (typeof HTMLCanvasElement !== "undefined" && canvas instanceof HTMLCanvasElement) {
            return canvas.getContext("2d");
          } else if (canvas instanceof OffscreenCanvas) {
            return canvas.getContext("2d");
          } else {
            return null;
          }
        };
        if (isHTMLImageEle) {
          const canvas = createCanvas();
          canvas.width = image.width;
          canvas.height = image.height;
          const pixels2DContext = createCanvasContext(canvas);
          if (pixels2DContext != null) {
            let height = image.height;
            let width = image.width;
            if (options !== void 0 && options.resizedHeight !== void 0 && options.resizedWidth !== void 0) {
              height = options.resizedHeight;
              width = options.resizedWidth;
            }
            if (options !== void 0) {
              bufferToTensorOptions = options;
              if (options.tensorFormat !== void 0) {
                throw new Error("Image input config format must be RGBA for HTMLImageElement");
              } else {
                bufferToTensorOptions.tensorFormat = "RGBA";
              }
              bufferToTensorOptions.height = height;
              bufferToTensorOptions.width = width;
            } else {
              bufferToTensorOptions.tensorFormat = "RGBA";
              bufferToTensorOptions.height = height;
              bufferToTensorOptions.width = width;
            }
            pixels2DContext.drawImage(image, 0, 0);
            data = pixels2DContext.getImageData(0, 0, width, height).data;
          } else {
            throw new Error("Can not access image data");
          }
        } else if (isImageDataEle) {
          let height;
          let width;
          if (options !== void 0 && options.resizedWidth !== void 0 && options.resizedHeight !== void 0) {
            height = options.resizedHeight;
            width = options.resizedWidth;
          } else {
            height = image.height;
            width = image.width;
          }
          if (options !== void 0) {
            bufferToTensorOptions = options;
          }
          bufferToTensorOptions.format = "RGBA";
          bufferToTensorOptions.height = height;
          bufferToTensorOptions.width = width;
          if (options !== void 0) {
            const tempCanvas = createCanvas();
            tempCanvas.width = width;
            tempCanvas.height = height;
            const pixels2DContext = createCanvasContext(tempCanvas);
            if (pixels2DContext != null) {
              pixels2DContext.putImageData(image, 0, 0);
              data = pixels2DContext.getImageData(0, 0, width, height).data;
            } else {
              throw new Error("Can not access image data");
            }
          } else {
            data = image.data;
          }
        } else if (isImageBitmap) {
          if (options === void 0) {
            throw new Error("Please provide image config with format for Imagebitmap");
          }
          const canvas = createCanvas();
          canvas.width = image.width;
          canvas.height = image.height;
          const pixels2DContext = createCanvasContext(canvas);
          if (pixels2DContext != null) {
            const height = image.height;
            const width = image.width;
            pixels2DContext.drawImage(image, 0, 0, width, height);
            data = pixels2DContext.getImageData(0, 0, width, height).data;
            bufferToTensorOptions.height = height;
            bufferToTensorOptions.width = width;
            return bufferToTensor(data, bufferToTensorOptions);
          } else {
            throw new Error("Can not access image data");
          }
        } else if (isString) {
          return new Promise((resolve, reject) => {
            const canvas = createCanvas();
            const context = createCanvasContext(canvas);
            if (!image || !context) {
              return reject();
            }
            const newImage = new Image();
            newImage.crossOrigin = "Anonymous";
            newImage.src = image;
            newImage.onload = () => {
              canvas.width = newImage.width;
              canvas.height = newImage.height;
              context.drawImage(newImage, 0, 0, canvas.width, canvas.height);
              const img = context.getImageData(0, 0, canvas.width, canvas.height);
              bufferToTensorOptions.height = canvas.height;
              bufferToTensorOptions.width = canvas.width;
              resolve(bufferToTensor(img.data, bufferToTensorOptions));
            };
          });
        } else {
          throw new Error("Input data provided is not supported - aborted tensor creation");
        }
        if (data !== void 0) {
          return bufferToTensor(data, bufferToTensorOptions);
        } else {
          throw new Error("Input data provided is not supported - aborted tensor creation");
        }
      };
      tensorFromTexture = (texture, options) => {
        const { width, height, download, dispose } = options;
        const dims = [1, height, width, 4];
        return new Tensor({ location: "texture", type: "float32", texture, dims, download, dispose });
      };
      tensorFromGpuBuffer = (gpuBuffer, options) => {
        const { dataType, dims, download, dispose } = options;
        return new Tensor({ location: "gpu-buffer", type: dataType ?? "float32", gpuBuffer, dims, download, dispose });
      };
      tensorFromMLTensor = (mlTensor, options) => {
        const { dataType, dims, download, dispose } = options;
        return new Tensor({ location: "ml-tensor", type: dataType ?? "float32", mlTensor, dims, download, dispose });
      };
      tensorFromPinnedBuffer = (type, buffer, dims) => new Tensor({ location: "cpu-pinned", type, data: buffer, dims: dims ?? [buffer.length] });
    }
  });

  // common/dist/esm/tensor-impl-type-mapping.js
  var NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP, NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, isTypedArrayChecked, checkTypedArray;
  var init_tensor_impl_type_mapping = __esm({
    "common/dist/esm/tensor-impl-type-mapping.js"() {
      "use strict";
      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = /* @__PURE__ */ new Map([
        ["float32", Float32Array],
        ["uint8", Uint8Array],
        ["int8", Int8Array],
        ["uint16", Uint16Array],
        ["int16", Int16Array],
        ["int32", Int32Array],
        ["bool", Uint8Array],
        ["float64", Float64Array],
        ["uint32", Uint32Array],
        ["int4", Uint8Array],
        ["uint4", Uint8Array]
      ]);
      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP = /* @__PURE__ */ new Map([
        [Float32Array, "float32"],
        [Uint8Array, "uint8"],
        [Int8Array, "int8"],
        [Uint16Array, "uint16"],
        [Int16Array, "int16"],
        [Int32Array, "int32"],
        [Float64Array, "float64"],
        [Uint32Array, "uint32"]
      ]);
      isTypedArrayChecked = false;
      checkTypedArray = () => {
        if (!isTypedArrayChecked) {
          isTypedArrayChecked = true;
          const isBigInt64ArrayAvailable = typeof BigInt64Array !== "undefined" && BigInt64Array.from;
          const isBigUint64ArrayAvailable = typeof BigUint64Array !== "undefined" && BigUint64Array.from;
          const Float16Array2 = globalThis.Float16Array;
          const isFloat16ArrayAvailable = typeof Float16Array2 !== "undefined" && Float16Array2.from;
          if (isBigInt64ArrayAvailable) {
            NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("int64", BigInt64Array);
            NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigInt64Array, "int64");
          }
          if (isBigUint64ArrayAvailable) {
            NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("uint64", BigUint64Array);
            NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigUint64Array, "uint64");
          }
          if (isFloat16ArrayAvailable) {
            NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("float16", Float16Array2);
            NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(Float16Array2, "float16");
          } else {
            NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set("float16", Uint16Array);
          }
        }
      };
    }
  });

  // common/dist/esm/tensor-utils-impl.js
  var calculateSize, tensorReshape;
  var init_tensor_utils_impl = __esm({
    "common/dist/esm/tensor-utils-impl.js"() {
      "use strict";
      init_tensor_impl();
      calculateSize = (dims) => {
        let size = 1;
        for (let i = 0; i < dims.length; i++) {
          const dim = dims[i];
          if (typeof dim !== "number" || !Number.isSafeInteger(dim)) {
            throw new TypeError(`dims[${i}] must be an integer, got: ${dim}`);
          }
          if (dim < 0) {
            throw new RangeError(`dims[${i}] must be a non-negative integer, got: ${dim}`);
          }
          size *= dim;
        }
        return size;
      };
      tensorReshape = (tensor, dims) => {
        switch (tensor.location) {
          case "cpu":
            return new Tensor(tensor.type, tensor.data, dims);
          case "cpu-pinned":
            return new Tensor({
              location: "cpu-pinned",
              data: tensor.data,
              type: tensor.type,
              dims
            });
          case "texture":
            return new Tensor({
              location: "texture",
              texture: tensor.texture,
              type: tensor.type,
              dims
            });
          case "gpu-buffer":
            return new Tensor({
              location: "gpu-buffer",
              gpuBuffer: tensor.gpuBuffer,
              type: tensor.type,
              dims
            });
          case "ml-tensor":
            return new Tensor({
              location: "ml-tensor",
              mlTensor: tensor.mlTensor,
              type: tensor.type,
              dims
            });
          default:
            throw new Error(`tensorReshape: tensor location ${tensor.location} is not supported`);
        }
      };
    }
  });

  // common/dist/esm/tensor-impl.js
  var Tensor;
  var init_tensor_impl = __esm({
    "common/dist/esm/tensor-impl.js"() {
      "use strict";
      init_tensor_conversion_impl();
      init_tensor_factory_impl();
      init_tensor_impl_type_mapping();
      init_tensor_utils_impl();
      Tensor = class {
        /**
         * implementation.
         */
        constructor(arg0, arg1, arg2) {
          checkTypedArray();
          let type;
          let dims;
          if (typeof arg0 === "object" && "location" in arg0) {
            this.dataLocation = arg0.location;
            type = arg0.type;
            dims = arg0.dims;
            switch (arg0.location) {
              case "cpu-pinned": {
                const expectedTypedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(type);
                if (!expectedTypedArrayConstructor) {
                  throw new TypeError(`unsupported type "${type}" to create tensor from pinned buffer`);
                }
                if (!(arg0.data instanceof expectedTypedArrayConstructor)) {
                  throw new TypeError(`buffer should be of type ${expectedTypedArrayConstructor.name}`);
                }
                this.cpuData = arg0.data;
                break;
              }
              case "texture": {
                if (type !== "float32") {
                  throw new TypeError(`unsupported type "${type}" to create tensor from texture`);
                }
                this.gpuTextureData = arg0.texture;
                this.downloader = arg0.download;
                this.disposer = arg0.dispose;
                break;
              }
              case "gpu-buffer": {
                if (type !== "float32" && type !== "float16" && type !== "int32" && type !== "int64" && type !== "uint32" && type !== "uint8" && type !== "bool" && type !== "uint4" && type !== "int4") {
                  throw new TypeError(`unsupported type "${type}" to create tensor from gpu buffer`);
                }
                this.gpuBufferData = arg0.gpuBuffer;
                this.downloader = arg0.download;
                this.disposer = arg0.dispose;
                break;
              }
              case "ml-tensor": {
                if (type !== "float32" && type !== "float16" && type !== "int32" && type !== "int64" && type !== "uint32" && type !== "uint64" && type !== "int8" && type !== "uint8" && type !== "bool" && type !== "uint4" && type !== "int4") {
                  throw new TypeError(`unsupported type "${type}" to create tensor from MLTensor`);
                }
                this.mlTensorData = arg0.mlTensor;
                this.downloader = arg0.download;
                this.disposer = arg0.dispose;
                break;
              }
              default:
                throw new Error(`Tensor constructor: unsupported location '${this.dataLocation}'`);
            }
          } else {
            let data;
            let maybeDims;
            if (typeof arg0 === "string") {
              type = arg0;
              maybeDims = arg2;
              if (arg0 === "string") {
                if (!Array.isArray(arg1)) {
                  throw new TypeError("A string tensor's data must be a string array.");
                }
                data = arg1;
              } else {
                const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0);
                if (typedArrayConstructor === void 0) {
                  throw new TypeError(`Unsupported tensor type: ${arg0}.`);
                }
                if (Array.isArray(arg1)) {
                  if (arg0 === "float16" && typedArrayConstructor === Uint16Array || arg0 === "uint4" || arg0 === "int4") {
                    throw new TypeError(`Creating a ${arg0} tensor from number array is not supported. Please use ${typedArrayConstructor.name} as data.`);
                  } else if (arg0 === "uint64" || arg0 === "int64") {
                    data = typedArrayConstructor.from(arg1, BigInt);
                  } else {
                    data = typedArrayConstructor.from(arg1);
                  }
                } else if (arg1 instanceof typedArrayConstructor) {
                  data = arg1;
                } else if (arg1 instanceof Uint8ClampedArray) {
                  if (arg0 === "uint8") {
                    data = Uint8Array.from(arg1);
                  } else {
                    throw new TypeError(`A Uint8ClampedArray tensor's data must be type of uint8`);
                  }
                } else if (arg0 === "float16" && arg1 instanceof Uint16Array && typedArrayConstructor !== Uint16Array) {
                  data = new globalThis.Float16Array(arg1.buffer, arg1.byteOffset, arg1.length);
                } else {
                  throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`);
                }
              }
            } else {
              maybeDims = arg1;
              if (Array.isArray(arg0)) {
                if (arg0.length === 0) {
                  throw new TypeError("Tensor type cannot be inferred from an empty array.");
                }
                const firstElementType = typeof arg0[0];
                if (firstElementType === "string") {
                  type = "string";
                  data = arg0;
                } else if (firstElementType === "boolean") {
                  type = "bool";
                  data = Uint8Array.from(arg0);
                } else {
                  throw new TypeError(`Invalid element type of data array: ${firstElementType}.`);
                }
              } else if (arg0 instanceof Uint8ClampedArray) {
                type = "uint8";
                data = Uint8Array.from(arg0);
              } else {
                const mappedType = NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(arg0.constructor);
                if (mappedType === void 0) {
                  throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`);
                }
                type = mappedType;
                data = arg0;
              }
            }
            if (maybeDims === void 0) {
              maybeDims = [data.length];
            } else if (!Array.isArray(maybeDims)) {
              throw new TypeError("A tensor's dims must be a number array");
            }
            dims = maybeDims;
            this.cpuData = data;
            this.dataLocation = "cpu";
          }
          const size = calculateSize(dims);
          if (this.cpuData && size !== this.cpuData.length) {
            if ((type === "uint4" || type === "int4") && Math.ceil(size / 2) === this.cpuData.length) {
            } else {
              throw new Error(`Tensor's size(${size}) does not match data length(${this.cpuData.length}).`);
            }
          }
          this.type = type;
          this.dims = dims;
          this.size = size;
        }
        // #endregion
        // #region factory
        static async fromImage(image, options) {
          return tensorFromImage(image, options);
        }
        static fromTexture(texture, options) {
          return tensorFromTexture(texture, options);
        }
        static fromGpuBuffer(gpuBuffer, options) {
          return tensorFromGpuBuffer(gpuBuffer, options);
        }
        static fromMLTensor(mlTensor, options) {
          return tensorFromMLTensor(mlTensor, options);
        }
        static fromPinnedBuffer(type, buffer, dims) {
          return tensorFromPinnedBuffer(type, buffer, dims);
        }
        // #endregion
        // #region conversions
        toDataURL(options) {
          return tensorToDataURL(this, options);
        }
        toImageData(options) {
          return tensorToImageData(this, options);
        }
        // #endregion
        // #region properties
        get data() {
          this.ensureValid();
          if (!this.cpuData) {
            throw new Error("The data is not on CPU. Use `getData()` to download GPU data to CPU, or use `texture` or `gpuBuffer` property to access the GPU data directly.");
          }
          return this.cpuData;
        }
        get location() {
          return this.dataLocation;
        }
        get texture() {
          this.ensureValid();
          if (!this.gpuTextureData) {
            throw new Error("The data is not stored as a WebGL texture.");
          }
          return this.gpuTextureData;
        }
        get gpuBuffer() {
          this.ensureValid();
          if (!this.gpuBufferData) {
            throw new Error("The data is not stored as a WebGPU buffer.");
          }
          return this.gpuBufferData;
        }
        get mlTensor() {
          this.ensureValid();
          if (!this.mlTensorData) {
            throw new Error("The data is not stored as a WebNN MLTensor.");
          }
          return this.mlTensorData;
        }
        // #endregion
        // #region methods
        async getData(releaseData) {
          this.ensureValid();
          switch (this.dataLocation) {
            case "cpu":
            case "cpu-pinned":
              return this.data;
            case "texture":
            case "gpu-buffer":
            case "ml-tensor": {
              if (!this.downloader) {
                throw new Error("The current tensor is not created with a specified data downloader.");
              }
              if (this.isDownloading) {
                throw new Error("The current tensor is being downloaded.");
              }
              try {
                this.isDownloading = true;
                const data = await this.downloader();
                this.downloader = void 0;
                this.dataLocation = "cpu";
                this.cpuData = data;
                if (releaseData && this.disposer) {
                  this.disposer();
                  this.disposer = void 0;
                }
                return data;
              } finally {
                this.isDownloading = false;
              }
            }
            default:
              throw new Error(`cannot get data from location: ${this.dataLocation}`);
          }
        }
        dispose() {
          if (this.isDownloading) {
            throw new Error("The current tensor is being downloaded.");
          }
          if (this.disposer) {
            this.disposer();
            this.disposer = void 0;
          }
          this.cpuData = void 0;
          this.gpuTextureData = void 0;
          this.gpuBufferData = void 0;
          this.mlTensorData = void 0;
          this.downloader = void 0;
          this.isDownloading = void 0;
          this.dataLocation = "none";
        }
        // #endregion
        // #region tensor utilities
        ensureValid() {
          if (this.dataLocation === "none") {
            throw new Error("The tensor is disposed.");
          }
        }
        reshape(dims) {
          this.ensureValid();
          if (this.downloader || this.disposer) {
            throw new Error("Cannot reshape a tensor that owns GPU resource.");
          }
          return tensorReshape(this, dims);
        }
      };
    }
  });

  // common/dist/esm/tensor.js
  var Tensor2;
  var init_tensor = __esm({
    "common/dist/esm/tensor.js"() {
      "use strict";
      init_tensor_impl();
      Tensor2 = Tensor;
    }
  });

  // common/dist/esm/trace.js
  var TRACE, TRACE_FUNC, TRACE_FUNC_BEGIN, TRACE_FUNC_END, 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 name of arg1) {
                if (typeof name !== "string") {
                  throw new TypeError("'fetches' must be a string array or an object.");
                }
                if (this.outputNames.indexOf(name) === -1) {
                  throw new RangeError(`'fetches' contains invalid output name: ${name}.`);
                }
                fetches[name] = null;
              }
              if (typeof arg2 === "object" && arg2 !== null) {
                options = arg2;
              } else if (typeof arg2 !== "undefined") {
                throw new TypeError("'options' must be an object.");
              }
            } else {
              let isFetches = false;
              const arg1Keys = Object.getOwnPropertyNames(arg1);
              for (const name of this.outputNames) {
                if (arg1Keys.indexOf(name) !== -1) {
                  const v = arg1[name];
                  if (v === null || v instanceof Tensor2) {
                    isFetches = true;
                    isFetchesEmpty = false;
                    fetches[name] = v;
                  }
                }
              }
              if (isFetches) {
                if (typeof arg2 === "object" && arg2 !== null) {
                  options = arg2;
                } else if (typeof arg2 !== "undefined") {
                  throw new TypeError("'options' must be an object.");
                }
              } else {
                options = arg1;
              }
            }
          } else if (typeof arg1 !== "undefined") {
            throw new TypeError("Unexpected argument[1]: must be 'fetches' or 'options'.");
          }
          for (const name of this.inputNames) {
            if (typeof feeds[name] === "undefined") {
              throw new Error(`input '${name}' is missing in 'feeds'.`);
            }
          }
          if (isFetchesEmpty) {
            for (const name of this.outputNames) {
              fetches[name] = null;
            }
          }
          const results = await this.handler.run(feeds, fetches, options);
          const returnValue = {};
          for (const key in results) {
            if (Object.hasOwnProperty.call(results, key)) {
              const result = results[key];
              if (result instanceof Tensor2) {
                returnValue[key] = result;
              } else {
                returnValue[key] = new Tensor2(result.type, result.data, result.dims);
              }
            }
          }
          TRACE_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 [backend, optionsWithValidatedEPs] = await resolveBackendAndExecutionProviders(options);
          const handler = await backend.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/wasm/wasm-utils-env.ts
  var isNode;
  var init_wasm_utils_env = __esm({
    "web/lib/wasm/wasm-utils-env.ts"() {
      "use strict";
      isNode = false;
    }
  });

  // web/lib/wasm/proxy-worker/main.ts
  var main_exports = {};
  __export(main_exports, {
    default: () => main_default
  });
  var WORKER_NAME, isProxyWorker, main_default;
  var init_main = __esm({
    "web/lib/wasm/proxy-worker/main.ts"() {
      "use strict";
      init_wasm_core_impl();
      init_wasm_factory();
      init_wasm_utils_import();
      WORKER_NAME = "ort-wasm-proxy-worker";
      isProxyWorker = globalThis.self?.name === WORKER_NAME;
      if (isProxyWorker) {
        self.onmessage = (ev) => {
          const { type, in: message } = ev.data;
          try {
            switch (type) {
              case "init-wasm":
                initializeWebAssembly(message.wasm).then(
                  () => {
                    initRuntime(message).then(
                      () => {
                        postMessage({ type });
                      },
                      (err) => {
                        postMessage({ type, err });
                      }
                    );
                  },
                  (err) => {
                    postMessage({ type, err });
                  }
                );
                break;
              case "init-ep": {
                const { epName, env: env3 } = message;
                initEp(env3, epName).then(
                  () => {
                    postMessage({ type });
                  },
                  (err) => {
                    postMessage({ type, err });
                  }
                );
                break;
              }
              case "copy-from": {
                const { buffer } = message;
                const bufferData = copyFromExternalBuffer(buffer);
                postMessage({ type, out: bufferData });
                break;
              }
              case "create": {
                const { model, options } = message;
                createSession(model, options).then(
                  (sessionMetadata) => {
                    postMessage({ type, out: sessionMetadata });
                  },
                  (err) => {
                    postMessage({ type, err });
                  }
                );
                break;
              }
              case "release":
                releaseSession(message);
                postMessage({ type });
                break;
              case "run": {
                const { sessionId, inputIndices, inputs, outputIndices, options } = message;
                run(sessionId, inputIndices, inputs, outputIndices, new Array(outputIndices.length).fill(null), options).then(
                  (outputs) => {
                    if (outputs.some((o) => o[3] !== "cpu")) {
                      postMessage({ type, err: "Proxy does not support non-cpu tensor location." });
                    } else {
                      postMessage(
                        { type, out: outputs },
                        extractTransferableBuffers([...inputs, ...outputs])
                      );
                    }
                  },
                  (err) => {
                    postMessage({ type, err });
                  }
                );
                break;
              }
              case "end-profiling":
                endProfiling(message);
                postMessage({ type });
                break;
              default:
            }
          } catch (err) {
            postMessage({ type, err });
          }
        };
      }
      main_default = isProxyWorker ? null : (urlOverride) => new Worker(urlOverride ?? scriptSrc, { type: false ? "module" : "classic", name: WORKER_NAME });
    }
  });

  // web/lib/wasm/wasm-utils-import.ts
  var origin, getScriptSrc, scriptSrc, inferWasmPathPrefixFromScriptSrc, isSameOrigin, normalizeUrl, fallbackUrl, preload, dynamicImportDefault, createProxyWorker, importProxyWorker, embeddedWasmModule, importWasmModule;
  var init_wasm_utils_import = __esm({
    "web/lib/wasm/wasm-utils-import.ts"() {
      "use strict";
      init_wasm_utils_env();
      origin = isNode || typeof location === "undefined" ? void 0 : location.origin;
      getScriptSrc = () => {
        if (isNode) {
          return void 0;
        }
        if (false) {
          if (isEsmImportMetaUrlHardcodedAsFileUri) {
            const URL2 = URL;
            return new URL(new URL2("ort.js", void 0).href, origin).href;
          }
          return void 0;
        }
        return typeof document !== "undefined" ? document.currentScript?.src : (
          // use `self.location.href` if available
          typeof self !== "undefined" ? self.location?.href : void 0
        );
      };
      scriptSrc = getScriptSrc();
      inferWasmPathPrefixFromScriptSrc = () => {
        if (scriptSrc && !scriptSrc.startsWith("blob:")) {
          return scriptSrc.substring(0, scriptSrc.lastIndexOf("/") + 1);
        }
        return void 0;
      };
      isSameOrigin = (filename, prefixOverride) => {
        try {
          const baseUrl = prefixOverride ?? scriptSrc;
          const url = baseUrl ? new URL(filename, baseUrl) : new URL(filename);
          return url.origin === origin;
        } catch {
          return false;
        }
      };
      normalizeUrl = (filename, prefixOverride) => {
        const baseUrl = prefixOverride ?? scriptSrc;
        try {
          const url = baseUrl ? new URL(filename, baseUrl) : new URL(filename);
          return url.href;
        } catch {
          return void 0;
        }
      };
      fallbackUrl = (filename, prefixOverride) => `${prefixOverride ?? "./"}${filename}`;
      preload = async (absoluteUrl) => {
        const response = await fetch(absoluteUrl, { credentials: "same-origin" });
        const blob = await response.blob();
        return URL.createObjectURL(blob);
      };
      dynamicImportDefault = async (url) => (await import(
        /* webpackIgnore: true */
        /* @vite-ignore */
        url
      )).default;
      createProxyWorker = // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
      false ? void 0 : (init_main(), __toCommonJS(main_exports)).default;
      importProxyWorker = async () => {
        if (!scriptSrc) {
          throw new Error("Failed to load proxy worker: cannot determine the script source URL.");
        }
        if (isSameOrigin(scriptSrc)) {
          return [void 0, createProxyWorker()];
        }
        const url = await preload(scriptSrc);
        return [url, createProxyWorker(url)];
      };
      embeddedWasmModule = false ? (
        // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
        (true ? null : false ? null : false ? null : null).default
      ) : void 0;
      importWasmModule = async (urlOverride, prefixOverride, isMultiThreaded, isWasmOverridden) => {
        let useEmbeddedModule = embeddedWasmModule && !(urlOverride || prefixOverride);
        if (useEmbeddedModule) {
          if (!scriptSrc) {
            if (isWasmOverridden && !isMultiThreaded) {
              useEmbeddedModule = true;
            } else {
              throw new Error("cannot determine the script source URL.");
            }
          } else {
            useEmbeddedModule = isSameOrigin(scriptSrc) || isWasmOverridden && !isMultiThreaded;
          }
        }
        if (useEmbeddedModule) {
          return [void 0, embeddedWasmModule];
        } else {
          const wasmModuleFilename = true ? "ort-wasm-simd-threaded.jsep.mjs" : false ? "ort-wasm-simd-threaded.jspi.mjs" : false ? "ort-wasm-simd-threaded.asyncify.mjs" : "ort-wasm-simd-threaded.mjs";
          const wasmModuleUrl = urlOverride ?? normalizeUrl(wasmModuleFilename, prefixOverride);
          const needPreload = !isNode && isMultiThreaded && wasmModuleUrl && !isSameOrigin(wasmModuleUrl, prefixOverride);
          const url = needPreload ? await preload(wasmModuleUrl) : wasmModuleUrl ?? fallbackUrl(wasmModuleFilename, prefixOverride);
          return [needPreload ? url : void 0, await dynamicImportDefault(url)];
        }
      };
    }
  });

  // web/lib/wasm/wasm-factory.ts
  var wasm, initialized, initializing, aborted, isMultiThreadSupported, isSimdSupported, isRelaxedSimdSupported, initializeWebAssembly, getInstance;
  var init_wasm_factory = __esm({
    "web/lib/wasm/wasm-factory.ts"() {
      "use strict";
      init_wasm_utils_import();
      initialized = false;
      initializing = false;
      aborted = false;
      isMultiThreadSupported = () => {
        if (typeof SharedArrayBuffer === "undefined") {
          return false;
        }
        try {
          if (typeof MessageChannel !== "undefined") {
            new MessageChannel().port1.postMessage(new SharedArrayBuffer(1));
          }
          return WebAssembly.validate(
            new Uint8Array([
              0,
              97,
              115,
              109,
              1,
              0,
              0,
              0,
              1,
              4,
              1,
              96,
              0,
              0,
              3,
              2,
              1,
              0,
              5,
              4,
              1,
              3,
              1,
              1,
              10,
              11,
              1,
              9,
              0,
              65,
              0,
              254,
              16,
              2,
              0,
              26,
              11
            ])
          );
        } catch {
          return false;
        }
      };
      isSimdSupported = () => {
        try {
          return WebAssembly.validate(
            new Uint8Array([
              0,
              97,
              115,
              109,
              1,
              0,
              0,
              0,
              1,
              4,
              1,
              96,
              0,
              0,
              3,
              2,
              1,
              0,
              10,
              30,
              1,
              28,
              0,
              65,
              0,
              253,
              15,
              253,
              12,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              253,
              186,
              1,
              26,
              11
            ])
          );
        } catch {
          return false;
        }
      };
      isRelaxedSimdSupported = () => {
        try {
          return WebAssembly.validate(
            new Uint8Array([
              0,
              97,
              115,
              109,
              1,
              0,
              0,
              0,
              1,
              5,
              1,
              96,
              0,
              1,
              123,
              3,
              2,
              1,
              0,
              10,
              19,
              1,
              17,
              0,
              65,
              1,
              253,
              15,
              65,
              2,
              253,
              15,
              65,
              3,
              253,
              15,
              253,
              147,
              2,
              11
            ])
          );
        } catch {
          return false;
        }
      };
      initializeWebAssembly = async (flags) => {
        if (initialized) {
          return Promise.resolve();
        }
        if (initializing) {
          throw new Error("multiple calls to 'initializeWebAssembly()' detected.");
        }
        if (aborted) {
          throw new Error("previous call to 'initializeWebAssembly()' failed.");
        }
        initializing = true;
        const timeout = flags.initTimeout;
        let numThreads = flags.numThreads;
        if (flags.simd === false) {
        } else if (flags.simd === "relaxed") {
          if (!isRelaxedSimdSupported()) {
            throw new Error("Relaxed WebAssembly SIMD is not supported in the current environment.");
          }
        } else if (!isSimdSupported()) {
          throw new Error("WebAssembly SIMD is not supported in the current environment.");
        }
        if (false) {
          if (!("Suspending" in WebAssembly)) {
            throw new Error("WebAssembly JSPI is not supported in the current environment.");
          }
        }
        const multiThreadSupported = isMultiThreadSupported();
        if (numThreads > 1 && !multiThreadSupported) {
          if (typeof self !== "undefined" && !self.crossOriginIsolated) {
            console.warn(
              "env.wasm.numThreads is set to " + numThreads + ", but this will not work unless you enable crossOriginIsolated mode. See https://web.dev/cross-origin-isolation-guide/ for more info."
            );
          }
          console.warn(
            "WebAssembly multi-threading is not supported in the current environment. Falling back to single-threading."
          );
          flags.numThreads = numThreads = 1;
        }
        const wasmPaths = flags.wasmPaths;
        const wasmPrefixOverride = typeof wasmPaths === "string" ? wasmPaths : void 0;
        const mjsPathOverrideFlag = wasmPaths?.mjs;
        const mjsPathOverride = mjsPathOverrideFlag?.href ?? mjsPathOverrideFlag;
        const wasmPathOverrideFlag = wasmPaths?.wasm;
        const wasmPathOverride = wasmPathOverrideFlag?.href ?? wasmPathOverrideFlag;
        const wasmBinaryOverride = flags.wasmBinary;
        const [objectUrl, ortWasmFactory] = await importWasmModule(
          mjsPathOverride,
          wasmPrefixOverride,
          numThreads > 1,
          !!wasmBinaryOverride || !!wasmPathOverride
        );
        let isTimeout = false;
        const tasks = [];
        if (timeout > 0) {
          tasks.push(
            new Promise((resolve) => {
              setTimeout(() => {
                isTimeout = true;
                resolve();
              }, timeout);
            })
          );
        }
        tasks.push(
          new Promise((resolve, reject) => {
            const config = {
              /**
               * The number of threads. WebAssembly will create (Module.numThreads - 1) workers. If it is 1, no worker will be
               * created.
               */
              numThreads
            };
            if (wasmBinaryOverride) {
              config.wasmBinary = wasmBinaryOverride;
              config.locateFile = (fileName) => fileName;
            } else if (wasmPathOverride || wasmPrefixOverride) {
              config.locateFile = (fileName) => wasmPathOverride ?? wasmPrefixOverride + fileName;
            } else if (mjsPathOverride && mjsPathOverride.indexOf("blob:") !== 0) {
              config.locateFile = (fileName) => new URL(fileName, mjsPathOverride).href;
            } else if (objectUrl) {
              const inferredWasmPathPrefix = inferWasmPathPrefixFromScriptSrc();
              if (inferredWasmPathPrefix) {
                config.locateFile = (fileName) => inferredWasmPathPrefix + fileName;
              }
            }
            ortWasmFactory(config).then(
              // wasm module initialized successfully
              (module) => {
                initializing = false;
                initialized = true;
                wasm = module;
                resolve();
                if (objectUrl) {
                  URL.revokeObjectURL(objectUrl);
                }
              },
              // wasm module failed to initialize
              (what) => {
                initializing = false;
                aborted = true;
                reject(what);
              }
            );
          })
        );
        await Promise.race(tasks);
        if (isTimeout) {
          throw new Error(`WebAssembly backend initializing failed due to timeout: ${timeout}ms`);
        }
      };
      getInstance = () => {
        if (initialized && wasm) {
          return wasm;
        }
        throw new Error("WebAssembly is not initialized yet.");
      };
    }
  });

  // web/lib/wasm/wasm-utils.ts
  var allocWasmString, iterateExtraOptions, checkLastError;
  var init_wasm_utils = __esm({
    "web/lib/wasm/wasm-utils.ts"() {
      "use strict";
      init_wasm_factory();
      allocWasmString = (data, allocs) => {
        const wasm2 = getInstance();
        const dataLength = wasm2.lengthBytesUTF8(data) + 1;
        const dataOffset = wasm2._malloc(dataLength);
        wasm2.stringToUTF8(data, dataOffset, dataLength);
        allocs.push(dataOffset);
        return dataOffset;
      };
      iterateExtraOptions = (options, prefix, seen, handler) => {
        if (typeof options == "object" && options !== null) {
          if (seen.has(options)) {
            throw new Error("Circular reference in options");
          } else {
            seen.add(options);
          }
        }
        Object.entries(options).forEach(([key, value]) => {
          const name = prefix ? prefix + key : key;
          if (typeof value === "object") {
            iterateExtraOptions(value, name + ".", seen, handler);
          } else if (typeof value === "string" || typeof value === "number") {
            handler(name, value.toString());
          } else if (typeof value === "boolean") {
            handler(name, value ? "1" : "0");
          } else {
            throw new Error(`Can't handle extra config type: ${typeof value}`);
          }
        });
      };
      checkLastError = (message) => {
        const wasm2 = getInstance();
        const stack = wasm2.stackSave();
        try {
          const ptrSize = wasm2.PTR_SIZE;
          const paramsOffset = wasm2.stackAlloc(2 * ptrSize);
          wasm2._OrtGetLastError(paramsOffset, paramsOffset + ptrSize);
          const errorCode = Number(wasm2.getValue(paramsOffset, ptrSize === 4 ? "i32" : "i64"));
          const errorMessagePointer = wasm2.getValue(paramsOffset + ptrSize, "*");
          const errorMessage = errorMessagePointer ? wasm2.UTF8ToString(errorMessagePointer) : "";
          throw new Error(`${message} ERROR_CODE: ${errorCode}, ERROR_MESSAGE: ${errorMessage}`);
        } finally {
          wasm2.stackRestore(stack);
        }
      };
    }
  });

  // web/lib/wasm/run-options.ts
  var setRunOptions;
  var init_run_options = __esm({
    "web/lib/wasm/run-options.ts"() {
      "use strict";
      init_wasm_factory();
      init_wasm_utils();
      setRunOptions = (options) => {
        const wasm2 = getInstance();
        let runOptionsHandle = 0;
        const allocs = [];
        const runOptions = options || {};
        try {
          if (options?.logSeverityLevel === void 0) {
            runOptions.logSeverityLevel = 2;
          } else if (typeof options.logSeverityLevel !== "number" || !Number.isInteger(options.logSeverityLevel) || options.logSeverityLevel < 0 || options.logSeverityLevel > 4) {
            throw new Error(`log severity level is not valid: ${options.logSeverityLevel}`);
          }
          if (options?.logVerbosityLevel === void 0) {
            runOptions.logVerbosityLevel = 0;
          } else if (typeof options.logVerbosityLevel !== "number" || !Number.isInteger(options.logVerbosityLevel)) {
            throw new Error(`log verbosity level is not valid: ${options.logVerbosityLevel}`);
          }
          if (options?.terminate === void 0) {
            runOptions.terminate = false;
          }
          let tagDataOffset = 0;
          if (options?.tag !== void 0) {
            tagDataOffset = allocWasmString(options.tag, allocs);
          }
          runOptionsHandle = wasm2._OrtCreateRunOptions(
            runOptions.logSeverityLevel,
            runOptions.logVerbosityLevel,
            !!runOptions.terminate,
            tagDataOffset
          );
          if (runOptionsHandle === 0) {
            checkLastError("Can't create run options.");
          }
          if (options?.extra !== void 0) {
            iterateExtraOptions(options.extra, "", /* @__PURE__ */ new WeakSet(), (key, value) => {
              const keyDataOffset = allocWasmString(key, allocs);
              const valueDataOffset = allocWasmString(value, allocs);
              if (wasm2._OrtAddRunConfigEntry(runOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {
                checkLastError(`Can't set a run config entry: ${key} - ${value}.`);
              }
            });
          }
          return [runOptionsHandle, allocs];
        } catch (e) {
          if (runOptionsHandle !== 0) {
            wasm2._OrtReleaseRunOptions(runOptionsHandle);
          }
          allocs.forEach((alloc) => wasm2._free(alloc));
          throw e;
        }
      };
    }
  });

  // web/lib/wasm/session-options.ts
  var getGraphOptimzationLevel, getExecutionMode, appendDefaultOptions, appendSessionConfig, setExecutionProviders, setSessionOptions;
  var init_session_options = __esm({
    "web/lib/wasm/session-options.ts"() {
      "use strict";
      init_wasm_factory();
      init_wasm_utils();
      getGraphOptimzationLevel = (graphOptimizationLevel) => {
        switch (graphOptimizationLevel) {
          case "disabled":
            return 0;
          case "basic":
            return 1;
          case "extended":
            return 2;
          case "layout":
            return 3;
          case "all":
            return 99;
          default:
            throw new Error(`unsupported graph optimization level: ${graphOptimizationLevel}`);
        }
      };
      getExecutionMode = (executionMode) => {
        switch (executionMode) {
          case "sequential":
            return 0;
          case "parallel":
            return 1;
          default:
            throw new Error(`unsupported execution mode: ${executionMode}`);
        }
      };
      appendDefaultOptions = (options) => {
        if (!options.extra) {
          options.extra = {};
        }
        if (!options.extra.session) {
          options.extra.session = {};
        }
        const session = options.extra.session;
        if (!session.use_ort_model_bytes_directly) {
          session.use_ort_model_bytes_directly = "1";
        }
        if (options.executionProviders && options.executionProviders.some((ep) => (typeof ep === "string" ? ep : ep.name) === "webgpu")) {
          options.enableMemPattern = false;
        }
      };
      appendSessionConfig = (sessionOptionsHandle, key, value, allocs) => {
        const keyDataOffset = allocWasmString(key, allocs);
        const valueDataOffset = allocWasmString(value, allocs);
        if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {
          checkLastError(`Can't set a session config entry: ${key} - ${value}.`);
        }
      };
      setExecutionProviders = async (sessionOptionsHandle, sessionOptions, allocs) => {
        const executionProviders = sessionOptions.executionProviders;
        for (const ep of executionProviders) {
          let epName = typeof ep === "string" ? ep : ep.name;
          const epOptions = [];
          switch (epName) {
            case "webnn":
              epName = "WEBNN";
              appendSessionConfig(sessionOptionsHandle, "session.disable_quant_qdq", "1", allocs);
              appendSessionConfig(sessionOptionsHandle, "session.disable_qdq_constant_folding", "1", allocs);
              if (typeof ep !== "string") {
                const webnnOptions = ep;
                const deviceType = webnnOptions?.deviceType;
                if (deviceType) {
                  appendSessionConfig(sessionOptionsHandle, "deviceType", deviceType, allocs);
                }
              }
              break;
            case "webgpu":
              if (false) {
                epName = "WebGPU";
                let customDevice;
                if (typeof ep !== "string") {
                  const webgpuOptions = ep;
                  if (webgpuOptions.device) {
                    if (typeof GPUDevice !== "undefined" && webgpuOptions.device instanceof GPUDevice) {
                      customDevice = webgpuOptions.device;
                    } else {
                      throw new Error("Invalid GPU device set in WebGPU EP options.");
                    }
                  }
                  const { enableGraphCapture } = sessionOptions;
                  if (typeof enableGraphCapture === "boolean" && enableGraphCapture) {
                    appendEpOption(epOptions, "enableGraphCapture", "1", allocs);
                  }
                  if (typeof webgpuOptions.preferredLayout === "string") {
                    appendEpOption(epOptions, "preferredLayout", webgpuOptions.preferredLayout, allocs);
                  }
                  if (webgpuOptions.forceCpuNodeNames) {
                    const names = Array.isArray(webgpuOptions.forceCpuNodeNames) ? webgpuOptions.forceCpuNodeNames : [webgpuOptions.forceCpuNodeNames];
                    appendEpOption(epOptions, "forceCpuNodeNames", names.join("\n"), allocs);
                  }
                  if (webgpuOptions.validationMode) {
                    appendEpOption(epOptions, "validationMode", webgpuOptions.validationMode, allocs);
                  }
                }
                const info = getInstance().webgpuRegisterDevice(customDevice);
                if (info) {
                  const [deviceId, instanceHandle, deviceHandle] = info;
                  appendEpOption(epOptions, "deviceId", deviceId.toString(), allocs);
                  appendEpOption(epOptions, "webgpuInstance", instanceHandle.toString(), allocs);
                  appendEpOption(epOptions, "webgpuDevice", deviceHandle.toString(), allocs);
                }
              } else {
                epName = "JS";
                if (typeof ep !== "string") {
                  const webgpuOptions = ep;
                  if (webgpuOptions?.preferredLayout) {
                    if (webgpuOptions.preferredLayout !== "NCHW" && webgpuOptions.preferredLayout !== "NHWC") {
                      throw new Error(`preferredLayout must be either 'NCHW' or 'NHWC': ${webgpuOptions.preferredLayout}`);
                    }
                    appendSessionConfig(sessionOptionsHandle, "preferredLayout", webgpuOptions.preferredLayout, allocs);
                  }
                }
              }
              break;
            case "wasm":
            case "cpu":
              continue;
            default:
              throw new Error(`not supported execution provider: ${epName}`);
          }
          const epNameDataOffset = allocWasmString(epName, allocs);
          const epOptionsCount = epOptions.length;
          let keysOffset = 0;
          let valuesOffset = 0;
          if (epOptionsCount > 0) {
            keysOffset = getInstance()._malloc(epOptionsCount * getInstance().PTR_SIZE);
            allocs.push(keysOffset);
            valuesOffset = getInstance()._malloc(epOptionsCount * getInstance().PTR_SIZE);
            allocs.push(valuesOffset);
            for (let i = 0; i < epOptionsCount; i++) {
              getInstance().setValue(keysOffset + i * getInstance().PTR_SIZE, epOptions[i][0], "*");
              getInstance().setValue(valuesOffset + i * getInstance().PTR_SIZE, epOptions[i][1], "*");
            }
          }
          if (await getInstance()._OrtAppendExecutionProvider(
            sessionOptionsHandle,
            epNameDataOffset,
            keysOffset,
            valuesOffset,
            epOptionsCount
          ) !== 0) {
            checkLastError(`Can't append execution provider: ${epName}.`);
          }
        }
      };
      setSessionOptions = async (options) => {
        const wasm2 = getInstance();
        let sessionOptionsHandle = 0;
        const allocs = [];
        const sessionOptions = options || {};
        appendDefaultOptions(sessionOptions);
        try {
          const graphOptimizationLevel = getGraphOptimzationLevel(sessionOptions.graphOptimizationLevel ?? "all");
          const executionMode = getExecutionMode(sessionOptions.executionMode ?? "sequential");
          const logIdDataOffset = typeof sessionOptions.logId === "string" ? allocWasmString(sessionOptions.logId, allocs) : 0;
          const logSeverityLevel = sessionOptions.logSeverityLevel ?? 2;
          if (!Number.isInteger(logSeverityLevel) || logSeverityLevel < 0 || logSeverityLevel > 4) {
            throw new Error(`log severity level is not valid: ${logSeverityLevel}`);
          }
          const logVerbosityLevel = sessionOptions.logVerbosityLevel ?? 0;
          if (!Number.isInteger(logVerbosityLevel) || logVerbosityLevel < 0 || logVerbosityLevel > 4) {
            throw new Error(`log verbosity level is not valid: ${logVerbosityLevel}`);
          }
          const optimizedModelFilePathOffset = typeof sessionOptions.optimizedModelFilePath === "string" ? allocWasmString(sessionOptions.optimizedModelFilePath, allocs) : 0;
          sessionOptionsHandle = wasm2._OrtCreateSessionOptions(
            graphOptimizationLevel,
            !!sessionOptions.enableCpuMemArena,
            !!sessionOptions.enableMemPattern,
            executionMode,
            !!sessionOptions.enableProfiling,
            0,
            logIdDataOffset,
            logSeverityLevel,
            logVerbosityLevel,
            optimizedModelFilePathOffset
          );
          if (sessionOptionsHandle === 0) {
            checkLastError("Can't create session options.");
          }
          if (sessionOptions.executionProviders) {
            await setExecutionProviders(sessionOptionsHandle, sessionOptions, allocs);
          }
          if (sessionOptions.enableGraphCapture !== void 0) {
            if (typeof sessionOptions.enableGraphCapture !== "boolean") {
              throw new Error(`enableGraphCapture must be a boolean value: ${sessionOptions.enableGraphCapture}`);
            }
            appendSessionConfig(
              sessionOptionsHandle,
              "enableGraphCapture",
              sessionOptions.enableGraphCapture.toString(),
              allocs
            );
          }
          if (sessionOptions.freeDimensionOverrides) {
            for (const [name, value] of Object.entries(sessionOptions.freeDimensionOverrides)) {
              if (typeof name !== "string") {
                throw new Error(`free dimension override name must be a string: ${name}`);
              }
              if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
                throw new Error(`free dimension override value must be a non-negative integer: ${value}`);
              }
              const nameOffset = allocWasmString(name, allocs);
              if (wasm2._OrtAddFreeDimensionOverride(sessionOptionsHandle, nameOffset, value) !== 0) {
                checkLastError(`Can't set a free dimension override: ${name} - ${value}.`);
              }
            }
          }
          if (sessionOptions.extra !== void 0) {
            iterateExtraOptions(sessionOptions.extra, "", /* @__PURE__ */ new WeakSet(), (key, value) => {
              appendSessionConfig(sessionOptionsHandle, key, value, allocs);
            });
          }
          return [sessionOptionsHandle, allocs];
        } catch (e) {
          if (sessionOptionsHandle !== 0) {
            if (wasm2._OrtReleaseSessionOptions(sessionOptionsHandle) !== 0) {
              checkLastError("Can't release session options.");
            }
          }
          allocs.forEach((alloc) => wasm2._free(alloc));
          throw e;
        }
      };
    }
  });

  // web/lib/wasm/wasm-common.ts
  var tensorDataTypeStringToEnum, tensorDataTypeEnumToString, calculateTensorSizeInBytes, tensorTypeToTypedArrayConstructor, logLevelStringToEnum, isGpuBufferSupportedType, isMLTensorSupportedType, dataLocationStringToEnum;
  var init_wasm_common = __esm({
    "web/lib/wasm/wasm-common.ts"() {
      "use strict";
      tensorDataTypeStringToEnum = (type) => {
        switch (type) {
          case "int8":
            return 3 /* int8 */;
          case "uint8":
            return 2 /* uint8 */;
          case "bool":
            return 9 /* bool */;
          case "int16":
            return 5 /* int16 */;
          case "uint16":
            return 4 /* uint16 */;
          case "int32":
            return 6 /* int32 */;
          case "uint32":
            return 12 /* uint32 */;
          case "float16":
            return 10 /* float16 */;
          case "float32":
            return 1 /* float */;
          case "float64":
            return 11 /* double */;
          case "string":
            return 8 /* string */;
          case "int64":
            return 7 /* int64 */;
          case "uint64":
            return 13 /* uint64 */;
          case "int4":
            return 22 /* int4 */;
          case "uint4":
            return 21 /* uint4 */;
          default:
            throw new Error(`unsupported data type: ${type}`);
        }
      };
      tensorDataTypeEnumToString = (typeProto) => {
        switch (typeProto) {
          case 3 /* int8 */:
            return "int8";
          case 2 /* uint8 */:
            return "uint8";
          case 9 /* bool */:
            return "bool";
          case 5 /* int16 */:
            return "int16";
          case 4 /* uint16 */:
            return "uint16";
          case 6 /* int32 */:
            return "int32";
          case 12 /* uint32 */:
            return "uint32";
          case 10 /* float16 */:
            return "float16";
          case 1 /* float */:
            return "float32";
          case 11 /* double */:
            return "float64";
          case 8 /* string */:
            return "string";
          case 7 /* int64 */:
            return "int64";
          case 13 /* uint64 */:
            return "uint64";
          case 22 /* int4 */:
            return "int4";
          case 21 /* uint4 */:
            return "uint4";
          default:
            throw new Error(`unsupported data type: ${typeProto}`);
        }
      };
      calculateTensorSizeInBytes = (dateType, dimsOrSize) => {
        const elementSize = [
          -1,
          // undefined = 0
          4,
          // float = 1
          1,
          // uint8 = 2
          1,
          // int8 = 3
          2,
          // uint16 = 4
          2,
          // int16 = 5
          4,
          // int32 = 6
          8,
          // int64 = 7
          -1,
          // string = 8
          1,
          // bool = 9
          2,
          // float16 = 10
          8,
          // double = 11
          4,
          // uint32 = 12
          8,
          // uint64 = 13
          -1,
          // complex64 = 14
          -1,
          // complex128 = 15
          -1,
          // bfloat16 = 16
          -1,
          // FLOAT8E4M3FN = 17
          -1,
          // FLOAT8E4M3FNUZ = 18
          -1,
          // FLOAT8E5M2 = 19
          -1,
          // FLOAT8E5M2FNUZ = 20
          0.5,
          // uint4 = 21
          0.5
          // int4 = 22
        ][dateType];
        const size = typeof dimsOrSize === "number" ? dimsOrSize : dimsOrSize.reduce((a, b) => a * b, 1);
        return elementSize > 0 ? Math.ceil(size * elementSize) : void 0;
      };
      tensorTypeToTypedArrayConstructor = (type) => {
        switch (type) {
          case "float16":
            return typeof Float16Array !== "undefined" && Float16Array.from ? Float16Array : Uint16Array;
          case "float32":
            return Float32Array;
          case "uint8":
            return Uint8Array;
          case "int8":
            return Int8Array;
          case "uint16":
            return Uint16Array;
          case "int16":
            return Int16Array;
          case "int32":
            return Int32Array;
          case "bool":
            return Uint8Array;
          case "float64":
            return Float64Array;
          case "uint32":
            return Uint32Array;
          case "int64":
            return BigInt64Array;
          case "uint64":
            return BigUint64Array;
          default:
            throw new Error(`unsupported type: ${type}`);
        }
      };
      logLevelStringToEnum = (logLevel) => {
        switch (logLevel) {
          case "verbose":
            return 0;
          case "info":
            return 1;
          case "warning":
            return 2;
          case "error":
            return 3;
          case "fatal":
            return 4;
          default:
            throw new Error(`unsupported logging level: ${logLevel}`);
        }
      };
      isGpuBufferSupportedType = (type) => type === "float32" || type === "float16" || type === "int32" || type === "int64" || type === "uint32" || type === "uint8" || type === "bool" || type === "uint4" || type === "int4";
      isMLTensorSupportedType = (type) => type === "float32" || type === "float16" || type === "int32" || type === "int64" || type === "uint32" || type === "uint64" || type === "int8" || type === "uint8" || type === "bool" || type === "uint4" || type === "int4";
      dataLocationStringToEnum = (location2) => {
        switch (location2) {
          case "none":
            return 0;
          case "cpu":
            return 1;
          case "cpu-pinned":
            return 2;
          case "texture":
            return 3;
          case "gpu-buffer":
            return 4;
          case "ml-tensor":
            return 5;
          default:
            throw new Error(`unsupported data location: ${location2}`);
        }
      };
    }
  });

  // web/lib/wasm/wasm-utils-load-file.ts
  var loadFile;
  var init_wasm_utils_load_file = __esm({
    "web/lib/wasm/wasm-utils-load-file.ts"() {
      "use strict";
      init_wasm_utils_env();
      loadFile = async (file) => {
        if (typeof file === "string") {
          if (isNode) {
            try {
              const { readFile } = __require("node:fs/promises");
              return new Uint8Array(await readFile(file));
            } catch (e) {
              if (e.code === "ERR_FS_FILE_TOO_LARGE") {
                const { createReadStream } = __require("node:fs");
                const stream = createReadStream(file);
                const chunks = [];
                for await (const chunk of stream) {
                  chunks.push(chunk);
                }
                return new Uint8Array(Buffer.concat(chunks));
              }
              throw e;
            }
          } else {
            const response = await fetch(file);
            if (!response.ok) {
              throw new Error(`failed to load external data file: ${file}`);
            }
            const contentLengthHeader = response.headers.get("Content-Length");
            const fileSize = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;
            if (fileSize < 1073741824) {
              return new Uint8Array(await response.arrayBuffer());
            } else {
              if (!response.body) {
                throw new Error(`failed to load external data file: ${file}, no response body.`);
              }
              const reader = response.body.getReader();
              let buffer;
              try {
                buffer = new ArrayBuffer(fileSize);
              } catch (e) {
                if (e instanceof RangeError) {
                  const pages = Math.ceil(fileSize / 65536);
                  buffer = new WebAssembly.Memory({ initial: pages, maximum: pages }).buffer;
                } else {
                  throw e;
                }
              }
              let offset = 0;
              while (true) {
                const { done, value } = await reader.read();
                if (done) {
                  break;
                }
                const chunkSize = value.byteLength;
                const chunk = new Uint8Array(buffer, offset, chunkSize);
                chunk.set(value);
                offset += chunkSize;
              }
              return new Uint8Array(buffer, 0, fileSize);
            }
          }
        } else if (file instanceof Blob) {
          return new Uint8Array(await file.arrayBuffer());
        } else if (file instanceof Uint8Array) {
          return file;
        } else {
          return new Uint8Array(file);
        }
      };
    }
  });

  // web/lib/wasm/jsep/log.ts
  var logLevelPrefix, doLog, configLogLevel, debug, configureLogger, LOG, LOG_DEBUG;
  var init_log = __esm({
    "web/lib/wasm/jsep/log.ts"() {
      "use strict";
      init_wasm_common();
      logLevelPrefix = ["V", "I", "W", "E", "F"];
      doLog = (level, message) => {
        console.log(`[${logLevelPrefix[level]},${(/* @__PURE__ */ new Date()).toISOString()}]${message}`);
      };
      configureLogger = ($configLogLevel, $debug) => {
        configLogLevel = $configLogLevel;
        debug = $debug;
      };
      LOG = (logLevel, msg) => {
        const messageLevel = logLevelStringToEnum(logLevel);
        const configLevel = logLevelStringToEnum(configLogLevel);
        if (messageLevel >= configLevel) {
          doLog(messageLevel, typeof msg === "function" ? msg() : msg);
        }
      };
      LOG_DEBUG = (...args) => {
        if (debug) {
          LOG(...args);
        }
      };
    }
  });

  // web/lib/wasm/jsep/util.ts
  var MatMulUtil, BroadcastUtil, ShapeUtil, PoolConvUtil, GemmUtil, MIN_CLIP, MAX_CLIP;
  var init_util = __esm({
    "web/lib/wasm/jsep/util.ts"() {
      "use strict";
      MatMulUtil = class {
        /**
         * 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 {
        /**
         * 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;
            }
            const max = Math.max(aLen, bLen);
            if (aLen && bLen) {
              cdims[crank - i] = Math.max(aLen, bLen);
            } else {
              if (max > 1) {
                return void 0;
              }
              cdims[crank - i] = 0;
            }
          }
          return cdims;
        }
        /**
         * Determine if a shape is unidirectional broadcastable to another shape
         * @param shape The input shape
         * @param finalShape The desired shape after broadcasting
         */
        static isValidBroadcast(shape, finalShape) {
          const inputRank = shape.length;
          const finalRank = finalShape.length;
          if (inputRank > finalRank) {
            return false;
          }
          for (let i = 1; i <= inputRank; i++) {
            if (shape[inputRank - i] !== 1 && shape[inputRank - i] !== finalShape[finalRank - i]) {
              return false;
            }
          }
          return true;
        }
      };
      ShapeUtil = class _ShapeUtil {
        /**
         * calculate the size (number of elements)
         */
        static size(dims) {
          return _ShapeUtil.getSizeFromDimensionRange(dims, 0, dims.length);
        }
        /**
         * convert dims corresponding to type change to pack. ex. uint8 data to uint32
         */
        static convertShape(dims, size = 4) {
          const rank = dims.length;
          if (rank === 0) {
            return [];
          }
          const newDims = new Array(rank);
          let i = rank - 1;
          while (i >= 0) {
            if (dims[i] % size === 0) {
              newDims[i] = dims[i] / size;
              break;
            }
            if (size % dims[i] !== 0) {
              throw new Error("cannot convert shape");
            }
            newDims[i] = 1;
            size /= dims[i];
            i--;
          }
          for (i--; i >= 0; i--) {
            newDims[i] = dims[i];
          }
          return newDims;
        }
        /**
         * calculate the size (number of elements) from the given 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);
        }
        /**
         * calculate the size (number of elements) to the given 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);
        }
        /**
         * calculate the size (number of elements) from and to the given axis [start, end)
         */
        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 negative values in them."
              );
            }
            size *= Number(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;
        }
        /**
         * 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 ?? axes.length));
        }
        /**
         * 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, pad2) {
          const rank = dims.length;
          return dims.map((v, i) => v + pad2[i] + pad2[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]);
        }
      };
      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, isChannelLast, 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 + (isChannelLast ? 1 : 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.
         */
        static computePoolOutputShape(isGlobalOperator, inputDims, strides, dilations, kernelShape, pads, autoPad) {
          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
          );
          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) {
          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
                )
              );
            }
          }
        }
        // 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) {
          const dkernel = dilation * (kernel - 1) + 1;
          if (autoPad && autoPad !== "NOTSET") {
            switch (autoPad) {
              case "VALID":
                pads[padHeadIndex] = 0;
                pads[padTailIndex] = 0;
                return Math.floor((inSize - dkernel) / stride + 1);
              case "SAME_LOWER":
              case "SAME_UPPER":
                if (dilation !== 1) {
                  throw new Error("Dilation not supported for SAME_UPPER or SAME_LOWER");
                } else {
                  const legacyTargetSize = (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 Math.floor((inSize + padNeeded - kernel) / stride + 1);
                }
              default:
                throw new Error("Unsupported AutoPad type");
            }
          } else {
            return Math.floor((inSize + pads[padHeadIndex] + pads[padTailIndex] - dkernel) / stride + 1);
          }
        }
      };
      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];
        }
      };
      MIN_CLIP = -34028234663852886e22;
      MAX_CLIP = 34028234663852886e22;
    }
  });

  // web/lib/wasm/jsep/tensor-view.ts
  var createView;
  var init_tensor_view = __esm({
    "web/lib/wasm/jsep/tensor-view.ts"() {
      "use strict";
      init_wasm_common();
      createView = (dataBuffer, type) => new (tensorTypeToTypedArrayConstructor(type))(dataBuffer);
    }
  });

  // web/lib/wasm/jsep/webnn/tensor-manager.ts
  var webnnDataTypeToSize, convertDataToInt32, convertInt32ToData, tensorGuid, createNewTensorId, webnnDataTypeToFallback, calculateByteLength, TensorWrapper, TensorIdTracker, TensorManagerImpl, createTensorManager;
  var init_tensor_manager = __esm({
    "web/lib/wasm/jsep/webnn/tensor-manager.ts"() {
      "use strict";
      init_wasm_common();
      init_log();
      webnnDataTypeToSize = /* @__PURE__ */ new Map([
        ["float32", 32],
        ["float16", 16],
        ["int32", 32],
        ["uint32", 32],
        ["int64", 64],
        ["uint64", 64],
        ["int8", 8],
        ["uint8", 8],
        ["int4", 4],
        ["uint4", 4]
      ]);
      convertDataToInt32 = (data, dataType) => {
        if (dataType === "int32") {
          return data;
        }
        const dataTypeSize = webnnDataTypeToSize.get(dataType);
        if (!dataTypeSize) {
          throw new Error(`WebNN backend does not support data type: ${dataType}`);
        }
        const bytesPerElement = dataTypeSize / 8;
        if (data.byteLength % bytesPerElement !== 0) {
          throw new Error(`Invalid Uint8Array length - must be a multiple of ${bytesPerElement}.`);
        }
        const numElements = data.byteLength / bytesPerElement;
        const originalArray = new (tensorTypeToTypedArrayConstructor(dataType))(data.buffer, data.byteOffset, numElements);
        switch (dataType) {
          case "int64":
          case "uint64": {
            const int32Array = new Int32Array(numElements);
            for (let i = 0; i < numElements; i++) {
              const value = originalArray[i];
              if (value > 2147483647n || value < -2147483648n) {
                throw new Error(`Can not convert int64 data to int32 - value out of range.`);
              }
              int32Array[i] = Number(value);
            }
            return new Uint8Array(int32Array.buffer);
          }
          case "int8":
          case "uint8":
          case "uint32": {
            if (dataType === "uint32") {
              if (originalArray.some((value) => value > 2147483647)) {
                throw new Error(`Can not convert uint32 data to int32 - value out of range.`);
              }
            }
            const int32Array = Int32Array.from(originalArray, Number);
            return new Uint8Array(int32Array.buffer);
          }
          default:
            throw new Error(`Unsupported data conversion from ${dataType} to 'int32'`);
        }
      };
      convertInt32ToData = (data, dataType) => {
        if (dataType === "int32") {
          return data;
        }
        if (data.byteLength % 4 !== 0) {
          throw new Error("Invalid Uint8Array length - must be a multiple of 4 (int32).");
        }
        const numElements = data.byteLength / 4;
        const int32Array = new Int32Array(data.buffer, data.byteOffset, numElements);
        switch (dataType) {
          case "int64": {
            const bigInt64Array = BigInt64Array.from(int32Array, BigInt);
            return new Uint8Array(bigInt64Array.buffer);
          }
          case "uint64": {
            if (int32Array.some((value) => value < 0)) {
              throw new Error("Can not convert int32 data to uin64 - negative value found.");
            }
            const bigUint64Array = BigUint64Array.from(int32Array, BigInt);
            return new Uint8Array(bigUint64Array.buffer);
          }
          case "int8": {
            if (int32Array.some((value) => value < -128 || value > 127)) {
              throw new Error("Can not convert int32 data to int8 - value out of range.");
            }
            const int8Array = Int8Array.from(int32Array, Number);
            return new Uint8Array(int8Array.buffer);
          }
          case "uint8": {
            if (int32Array.some((value) => value < 0 || value > 255)) {
              throw new Error("Can not convert int32 data to uint8 - value out of range.");
            }
            return Uint8Array.from(int32Array, Number);
          }
          case "uint32": {
            if (int32Array.some((value) => value < 0)) {
              throw new Error("Can not convert int32 data to uint32 - negative value found.");
            }
            const uint32Array = Uint32Array.from(int32Array, Number);
            return new Uint8Array(uint32Array.buffer);
          }
          default:
            throw new Error(`Unsupported data conversion from 'int32' to ${dataType}`);
        }
      };
      tensorGuid = 1;
      createNewTensorId = () => tensorGuid++;
      webnnDataTypeToFallback = /* @__PURE__ */ new Map([
        ["int8", "int32"],
        ["uint8", "int32"],
        ["uint32", "int32"],
        ["int64", "int32"]
      ]);
      calculateByteLength = (dataType, shape) => {
        const dataTypeSize = webnnDataTypeToSize.get(dataType);
        if (!dataTypeSize) {
          throw new Error(`WebNN backend does not support data type: ${dataType}`);
        }
        return shape.length > 0 ? Math.ceil(shape.reduce((a, b) => a * b) * dataTypeSize / 8) : 0;
      };
      TensorWrapper = class {
        constructor(descriptor) {
          // This flag is used to indicate whether the data has been converted to fallback data type.
          this.isDataConverted = false;
          const { sessionId, context, tensor, dataType, shape, fallbackDataType } = descriptor;
          this.sessionId = sessionId;
          this.mlContext = context;
          this.mlTensor = tensor;
          this.dataType = dataType;
          this.tensorShape = shape;
          this.fallbackDataType = fallbackDataType;
        }
        get tensor() {
          return this.mlTensor;
        }
        get type() {
          return this.dataType;
        }
        get fallbackType() {
          return this.fallbackDataType;
        }
        get shape() {
          return this.tensorShape;
        }
        get byteLength() {
          return calculateByteLength(this.dataType, this.tensorShape);
        }
        destroy() {
          LOG_DEBUG("verbose", () => "[WebNN] TensorWrapper.destroy");
          this.mlTensor.destroy();
        }
        write(data) {
          this.mlContext.writeTensor(this.mlTensor, data);
        }
        async read(dstBuffer) {
          if (this.fallbackDataType) {
            const data = await this.mlContext.readTensor(this.mlTensor);
            const originalData = convertInt32ToData(new Uint8Array(data), this.dataType);
            if (dstBuffer) {
              const targetBuffer = dstBuffer instanceof ArrayBuffer ? new Uint8Array(dstBuffer) : new Uint8Array(dstBuffer.buffer, dstBuffer.byteOffset, dstBuffer.byteLength);
              targetBuffer.set(originalData);
              return void 0;
            } else {
              return originalData.buffer;
            }
          } else {
            return dstBuffer ? this.mlContext.readTensor(this.mlTensor, dstBuffer) : this.mlContext.readTensor(this.mlTensor);
          }
        }
        canReuseTensor(context, dataType, shape) {
          return this.mlContext === context && this.dataType === dataType && this.tensorShape.length === shape.length && this.tensorShape.every((v, i) => v === shape[i]);
        }
        setIsDataConverted(isConverted) {
          this.isDataConverted = isConverted;
        }
      };
      TensorIdTracker = class {
        constructor(tensorManager, wrapper) {
          this.tensorManager = tensorManager;
          this.wrapper = wrapper;
        }
        get tensorWrapper() {
          return this.wrapper;
        }
        releaseTensor() {
          if (this.tensorWrapper) {
            this.tensorManager.releaseTensor(this.tensorWrapper);
            this.wrapper = void 0;
          }
        }
        async ensureTensor(sessionId, dataType, shape, copyOld) {
          const context = this.tensorManager.getMLContext(sessionId);
          const opLimits = this.tensorManager.getMLOpSupportLimits(sessionId);
          let fallbackDataType;
          if (!opLimits?.input.dataTypes.includes(dataType)) {
            fallbackDataType = webnnDataTypeToFallback.get(dataType);
            if (!fallbackDataType || opLimits?.input.dataTypes.includes(fallbackDataType)) {
              throw new Error(`WebNN backend does not support data type: ${dataType}`);
            }
            LOG_DEBUG(
              "verbose",
              () => `[WebNN] TensorIdTracker.ensureTensor: fallback dataType from ${dataType} to ${fallbackDataType}`
            );
          }
          if (this.wrapper) {
            if (this.wrapper.canReuseTensor(context, dataType, shape)) {
              return this.wrapper.tensor;
            } else {
              if (copyOld) {
                if (this.wrapper.byteLength !== calculateByteLength(dataType, shape)) {
                  throw new Error("Unable to copy data to tensor with different size.");
                }
                this.activeUpload = new Uint8Array(await this.wrapper.read());
              }
              this.tensorManager.releaseTensor(this.wrapper);
            }
          }
          const usage = typeof MLTensorUsage == "undefined" ? void 0 : MLTensorUsage.READ | MLTensorUsage.WRITE;
          this.wrapper = await this.tensorManager.getCachedTensor(
            sessionId,
            dataType,
            shape,
            usage,
            true,
            true,
            fallbackDataType
          );
          if (copyOld && this.activeUpload) {
            this.wrapper.write(this.activeUpload);
            this.activeUpload = void 0;
          }
          return this.wrapper.tensor;
        }
        upload(data) {
          let newData = data;
          if (this.wrapper) {
            if (this.wrapper.fallbackType) {
              if (this.wrapper.fallbackType === "int32") {
                newData = convertDataToInt32(data, this.wrapper.type);
                this.wrapper.setIsDataConverted(true);
              } else {
                throw new Error(`Unsupported fallback data type: ${this.wrapper.fallbackType}`);
              }
            }
            if (data.byteLength === this.wrapper.byteLength) {
              this.wrapper.write(newData);
              return;
            } else {
              LOG_DEBUG("verbose", () => "Data size does not match tensor size. Releasing tensor.");
              this.releaseTensor();
            }
          }
          if (this.activeUpload) {
            this.activeUpload.set(newData);
          } else {
            this.activeUpload = new Uint8Array(newData);
          }
        }
        async download(dstBuffer) {
          if (this.activeUpload) {
            const dstData = this.wrapper?.isDataConverted ? convertInt32ToData(this.activeUpload, this.wrapper?.type) : this.activeUpload;
            if (dstBuffer) {
              if (dstBuffer instanceof ArrayBuffer) {
                new Uint8Array(dstBuffer).set(dstData);
              } else {
                new Uint8Array(dstBuffer.buffer, dstBuffer.byteOffset, dstBuffer.byteLength).set(dstData);
              }
              return;
            } else {
              return dstData.buffer;
            }
          }
          if (!this.wrapper) {
            throw new Error("Tensor has not been created.");
          }
          if (!dstBuffer) {
            return this.wrapper.read();
          }
          return this.wrapper.read(dstBuffer);
        }
      };
      TensorManagerImpl = class {
        constructor(backend) {
          this.backend = backend;
          this.tensorTrackersById = /* @__PURE__ */ new Map();
          this.freeTensors = [];
          this.externalTensors = /* @__PURE__ */ new Set();
        }
        getMLContext(sessionId) {
          const context = this.backend.getMLContext(sessionId);
          if (!context) {
            throw new Error("MLContext not found for session.");
          }
          return context;
        }
        getMLOpSupportLimits(sessionId) {
          return this.backend.getMLOpSupportLimits(sessionId);
        }
        reserveTensorId() {
          const tensorId = createNewTensorId();
          this.tensorTrackersById.set(tensorId, new TensorIdTracker(this));
          return tensorId;
        }
        releaseTensorId(tensorId) {
          const tensorTracker = this.tensorTrackersById.get(tensorId);
          if (!tensorTracker) {
            return;
          }
          this.tensorTrackersById.delete(tensorId);
          if (tensorTracker.tensorWrapper) {
            this.releaseTensor(tensorTracker.tensorWrapper);
          }
        }
        async ensureTensor(sessionId, tensorId, dataType, shape, copyOld) {
          LOG_DEBUG(
            "verbose",
            () => `[WebNN] TensorManager.ensureTensor {tensorId: ${tensorId}, dataType: ${dataType}, shape: ${shape}, copyOld: ${copyOld}}`
          );
          const tensor = this.tensorTrackersById.get(tensorId);
          if (!tensor) {
            throw new Error("Tensor not found.");
          }
          return tensor.ensureTensor(sessionId, dataType, shape, copyOld);
        }
        upload(tensorId, data) {
          const tensor = this.tensorTrackersById.get(tensorId);
          if (!tensor) {
            throw new Error("Tensor not found.");
          }
          tensor.upload(data);
        }
        async download(tensorId, dstBuffer) {
          LOG_DEBUG(
            "verbose",
            () => `[WebNN] TensorManager.download {tensorId: ${tensorId}, dstBuffer: ${dstBuffer?.byteLength}}`
          );
          const tensorTracker = this.tensorTrackersById.get(tensorId);
          if (!tensorTracker) {
            throw new Error("Tensor not found.");
          }
          return tensorTracker.download(dstBuffer);
        }
        releaseTensorsForSession(sessionId) {
          for (const tensor of this.freeTensors) {
            if (tensor.sessionId === sessionId) {
              tensor.destroy();
            }
          }
          this.freeTensors = this.freeTensors.filter((tensor) => tensor.sessionId !== sessionId);
        }
        registerTensor(sessionId, mlTensor, dataType, shape) {
          const context = this.getMLContext(sessionId);
          const tensorId = createNewTensorId();
          const wrapper = new TensorWrapper({
            sessionId,
            context,
            tensor: mlTensor,
            dataType,
            shape
          });
          this.tensorTrackersById.set(tensorId, new TensorIdTracker(this, wrapper));
          this.externalTensors.add(wrapper);
          return tensorId;
        }
        /**
         * Get or create an MLTensor with the given data type and shape.
         */
        async getCachedTensor(sessionId, dataType, shape, usage, writable, readable, fallbackDataType) {
          const context = this.getMLContext(sessionId);
          for (const [index, tensor2] of this.freeTensors.entries()) {
            if (tensor2.canReuseTensor(context, dataType, shape)) {
              LOG_DEBUG(
                "verbose",
                () => `[WebNN] Reusing tensor {dataType: ${dataType}, ${fallbackDataType ? `fallbackDataType: ${fallbackDataType},` : ""} shape: ${shape}`
              );
              const wrapper = this.freeTensors.splice(index, 1)[0];
              wrapper.sessionId = sessionId;
              return wrapper;
            }
          }
          LOG_DEBUG(
            "verbose",
            () => `[WebNN] MLContext.createTensor {dataType: ${dataType}, ${fallbackDataType ? `fallbackDataType: ${fallbackDataType},` : ""} shape: ${shape}}`
          );
          const tensor = await context.createTensor({
            dataType: fallbackDataType ?? dataType,
            // If fallback data type is provided, use it.
            shape,
            dimensions: shape,
            usage,
            writable,
            readable
          });
          return new TensorWrapper({ sessionId, context, tensor, dataType, shape, fallbackDataType });
        }
        /**
         * Release tensor for reuse unless external.
         */
        releaseTensor(tensorWrapper) {
          if (this.externalTensors.has(tensorWrapper)) {
            this.externalTensors.delete(tensorWrapper);
          }
          this.freeTensors.push(tensorWrapper);
        }
      };
      createTensorManager = (...args) => new TensorManagerImpl(...args);
    }
  });

  // web/lib/wasm/jsep/backend-webnn.ts
  var onnxDataTypeToWebnnDataType, compareMLContextOptions, WebNNBackend;
  var init_backend_webnn = __esm({
    "web/lib/wasm/jsep/backend-webnn.ts"() {
      "use strict";
      init_wasm_common();
      init_wasm_factory();
      init_tensor_view();
      init_tensor_manager();
      init_log();
      onnxDataTypeToWebnnDataType = /* @__PURE__ */ new Map([
        [1 /* float */, "float32"],
        [10 /* float16 */, "float16"],
        [6 /* int32 */, "int32"],
        [12 /* uint32 */, "uint32"],
        [7 /* int64 */, "int64"],
        [13 /* uint64 */, "uint64"],
        [22 /* int4 */, "int4"],
        [21 /* uint4 */, "uint4"],
        [3 /* int8 */, "int8"],
        [2 /* uint8 */, "uint8"],
        [9 /* bool */, "uint8"]
      ]);
      compareMLContextOptions = (a, b) => {
        if (a === b) {
          return true;
        }
        if (a === void 0 || b === void 0) {
          return false;
        }
        const aKeys = Object.keys(a).sort();
        const bKeys = Object.keys(b).sort();
        return aKeys.length === bKeys.length && aKeys.every((key, index) => key === bKeys[index] && a[key] === b[key]);
      };
      WebNNBackend = class {
        constructor(env3) {
          /**
           * Tensor managers for each session.
           */
          this.tensorManager = createTensorManager(this);
          /**
           * Maps from session id to MLContexts.
           */
          this.mlContextBySessionId = /* @__PURE__ */ new Map();
          /**
           * Maps from MLContext to session ids.
           */
          this.sessionIdsByMLContext = /* @__PURE__ */ new Map();
          /**
           * Cache of MLContexts.
           */
          this.mlContextCache = [];
          /**
           * Maps from session id to list of graph inputs.
           */
          this.sessionGraphInputs = /* @__PURE__ */ new Map();
          /**
           * Maps from session id to list of graph outputs.
           */
          this.sessionGraphOutputs = /* @__PURE__ */ new Map();
          /**
           * Temporary graph inputs for the current session.
           * These inputs will be registered when the session is created.
           */
          this.temporaryGraphInputs = [];
          /**
           * Temporary graph outputs for the current session.
           * These outputs will be registered when the session is created.
           */
          this.temporaryGraphOutputs = [];
          /**
           * Temporary tensors for the current session.
           */
          this.temporarySessionTensorIds = /* @__PURE__ */ new Map();
          /**
           * Maps from session id to MLOpSupportLimits.
           */
          this.mlOpSupportLimitsBySessionId = /* @__PURE__ */ new Map();
          configureLogger(env3.logLevel, !!env3.debug);
        }
        get currentSessionId() {
          if (this.activeSessionId === void 0) {
            throw new Error("No active session");
          }
          return this.activeSessionId;
        }
        onRunStart(sessionId) {
          LOG_DEBUG("verbose", () => `[WebNN] onRunStart {sessionId: ${sessionId}}`);
          this.activeSessionId = sessionId;
        }
        onRunEnd(sessionId) {
          LOG_DEBUG("verbose", () => `[WebNN] onRunEnd {sessionId: ${sessionId}}`);
          const tensorIds = this.temporarySessionTensorIds.get(sessionId);
          if (!tensorIds) {
            return;
          }
          for (const tensorId of tensorIds) {
            LOG_DEBUG("verbose", () => `[WebNN] releasing temporary tensor {tensorId: ${tensorId}}`);
            this.tensorManager.releaseTensorId(tensorId);
          }
          this.temporarySessionTensorIds.delete(sessionId);
          this.activeSessionId = void 0;
        }
        async createMLContext(optionsOrDevice) {
          if (optionsOrDevice instanceof GPUDevice) {
            const mlContextIndex2 = this.mlContextCache.findIndex((entry) => entry.gpuDevice === optionsOrDevice);
            if (mlContextIndex2 !== -1) {
              return this.mlContextCache[mlContextIndex2].mlContext;
            } else {
              const mlContext = await navigator.ml.createContext(optionsOrDevice);
              this.mlContextCache.push({ gpuDevice: optionsOrDevice, mlContext });
              return mlContext;
            }
          } else if (optionsOrDevice === void 0) {
            const mlContextIndex2 = this.mlContextCache.findIndex(
              (entry) => entry.options === void 0 && entry.gpuDevice === void 0
            );
            if (mlContextIndex2 !== -1) {
              return this.mlContextCache[mlContextIndex2].mlContext;
            } else {
              const mlContext = await navigator.ml.createContext();
              this.mlContextCache.push({ mlContext });
              return mlContext;
            }
          }
          const mlContextIndex = this.mlContextCache.findIndex(
            (entry) => compareMLContextOptions(entry.options, optionsOrDevice)
          );
          if (mlContextIndex !== -1) {
            return this.mlContextCache[mlContextIndex].mlContext;
          } else {
            const mlContext = await navigator.ml.createContext(optionsOrDevice);
            this.mlContextCache.push({ options: optionsOrDevice, mlContext });
            return mlContext;
          }
        }
        registerMLContext(sessionId, mlContext) {
          this.mlContextBySessionId.set(sessionId, mlContext);
          let sessionIds = this.sessionIdsByMLContext.get(mlContext);
          if (!sessionIds) {
            sessionIds = /* @__PURE__ */ new Set();
            this.sessionIdsByMLContext.set(mlContext, sessionIds);
          }
          sessionIds.add(sessionId);
          if (!this.mlOpSupportLimitsBySessionId.has(sessionId)) {
            this.mlOpSupportLimitsBySessionId.set(sessionId, mlContext.opSupportLimits());
          }
          if (this.temporaryGraphInputs.length > 0) {
            this.sessionGraphInputs.set(sessionId, this.temporaryGraphInputs);
            this.temporaryGraphInputs = [];
          }
          if (this.temporaryGraphOutputs.length > 0) {
            this.sessionGraphOutputs.set(sessionId, this.temporaryGraphOutputs);
            this.temporaryGraphOutputs = [];
          }
        }
        onReleaseSession(sessionId) {
          this.sessionGraphInputs.delete(sessionId);
          this.sessionGraphOutputs.delete(sessionId);
          const mlContext = this.mlContextBySessionId.get(sessionId);
          if (!mlContext) {
            return;
          }
          this.tensorManager.releaseTensorsForSession(sessionId);
          this.mlContextBySessionId.delete(sessionId);
          this.mlOpSupportLimitsBySessionId.delete(sessionId);
          const sessionIds = this.sessionIdsByMLContext.get(mlContext);
          sessionIds.delete(sessionId);
          if (sessionIds.size === 0) {
            this.sessionIdsByMLContext.delete(mlContext);
            const mlContextIndex = this.mlContextCache.findIndex((entry) => entry.mlContext === mlContext);
            if (mlContextIndex !== -1) {
              this.mlContextCache.splice(mlContextIndex, 1);
            }
          }
        }
        getMLContext(sessionId) {
          return this.mlContextBySessionId.get(sessionId);
        }
        getMLOpSupportLimits(sessionId) {
          return this.mlOpSupportLimitsBySessionId.get(sessionId);
        }
        reserveTensorId() {
          return this.tensorManager.reserveTensorId();
        }
        releaseTensorId(tensorId) {
          LOG_DEBUG("verbose", () => `[WebNN] releaseTensorId {tensorId: ${tensorId}}`);
          this.tensorManager.releaseTensorId(tensorId);
        }
        async ensureTensor(sessionId, tensorId, onnxDataType, dimensions, copyOld) {
          const webnnDataType = onnxDataTypeToWebnnDataType.get(onnxDataType);
          if (!webnnDataType) {
            throw new Error(`Unsupported ONNX data type: ${onnxDataType}`);
          }
          return this.tensorManager.ensureTensor(
            sessionId ?? this.currentSessionId,
            tensorId,
            webnnDataType,
            dimensions,
            copyOld
          );
        }
        async createTemporaryTensor(sessionId, onnxDataType, shape) {
          LOG_DEBUG("verbose", () => `[WebNN] createTemporaryTensor {onnxDataType: ${onnxDataType}, shape: ${shape}}`);
          const dataType = onnxDataTypeToWebnnDataType.get(onnxDataType);
          if (!dataType) {
            throw new Error(`Unsupported ONNX data type: ${onnxDataType}`);
          }
          const tensorId = this.tensorManager.reserveTensorId();
          await this.tensorManager.ensureTensor(sessionId, tensorId, dataType, shape, false);
          const tensorIds = this.temporarySessionTensorIds.get(sessionId);
          if (!tensorIds) {
            this.temporarySessionTensorIds.set(sessionId, [tensorId]);
          } else {
            tensorIds.push(tensorId);
          }
          return tensorId;
        }
        uploadTensor(tensorId, data) {
          const wasm2 = getInstance();
          if (!wasm2.shouldTransferToMLTensor) {
            throw new Error("Trying to upload to a MLTensor while shouldTransferToMLTensor is false");
          }
          LOG_DEBUG("verbose", () => `[WebNN] uploadTensor {tensorId: ${tensorId}, data: ${data.byteLength}}`);
          this.tensorManager.upload(tensorId, data);
        }
        async downloadTensor(tensorId, dstBuffer) {
          return this.tensorManager.download(tensorId, dstBuffer);
        }
        createMLTensorDownloader(tensorId, type) {
          return async () => {
            const data = await this.tensorManager.download(tensorId);
            return createView(data, type);
          };
        }
        registerMLTensor(sessionId, tensor, onnxDataType, dimensions) {
          const webnnDataType = onnxDataTypeToWebnnDataType.get(onnxDataType);
          if (!webnnDataType) {
            throw new Error(`Unsupported ONNX data type: ${onnxDataType}`);
          }
          const id = this.tensorManager.registerTensor(sessionId, tensor, webnnDataType, dimensions);
          LOG_DEBUG(
            "verbose",
            () => `[WebNN] registerMLTensor {tensor: ${tensor}, dataType: ${webnnDataType}, dimensions: ${dimensions}} -> {tensorId: ${id}}`
          );
          return id;
        }
        // Register a WebNN Constant operand from external data.
        registerMLConstant(externalFilePath, dataOffset, dataLength, builder, desc, mountedFiles, shouldConvertInt64ToInt32 = false) {
          if (!mountedFiles) {
            throw new Error("External mounted files are not available.");
          }
          let filePath = externalFilePath;
          if (externalFilePath.startsWith("./")) {
            filePath = externalFilePath.substring(2);
          }
          const fileData = mountedFiles.get(filePath);
          if (!fileData) {
            throw new Error(`File with name ${filePath} not found in preloaded files.`);
          }
          if (dataOffset + dataLength > fileData.byteLength) {
            throw new Error("Out of bounds: data offset and length exceed the external file data size.");
          }
          const buffer = fileData.slice(dataOffset, dataOffset + dataLength).buffer;
          let bufferView;
          switch (desc.dataType) {
            case "float32":
              bufferView = new Float32Array(buffer);
              break;
            case "float16":
              bufferView = typeof Float16Array !== "undefined" && Float16Array.from ? new Float16Array(buffer) : new Uint16Array(buffer);
              break;
            case "int32":
              bufferView = new Int32Array(buffer);
              break;
            case "uint32":
              bufferView = new Uint32Array(buffer);
              break;
            case "int64":
              if (shouldConvertInt64ToInt32) {
                const int32Buffer = convertDataToInt32(new Uint8Array(buffer), "int64");
                bufferView = new Int32Array(int32Buffer.buffer);
                desc.dataType = "int32";
              } else {
                bufferView = new BigInt64Array(buffer);
              }
              break;
            case "uint64":
              bufferView = new BigUint64Array(buffer);
              break;
            case "int8":
              bufferView = new Int8Array(buffer);
              break;
            case "int4":
            case "uint4":
            case "uint8":
              bufferView = new Uint8Array(buffer);
              break;
            default:
              throw new Error(`Unsupported data type: ${desc.dataType} in creating WebNN Constant from external data.`);
          }
          LOG_DEBUG(
            "verbose",
            () => `[WebNN] registerMLConstant {dataType: ${desc.dataType}, shape: ${desc.shape}}} ${shouldConvertInt64ToInt32 ? "(Note: it was int64 data type and registered to int32 as workaround)" : ""}`
          );
          return builder.constant(desc, bufferView);
        }
        registerGraphInput(inputName) {
          this.temporaryGraphInputs.push(inputName);
        }
        registerGraphOutput(outputName) {
          this.temporaryGraphOutputs.push(outputName);
        }
        isGraphInput(sessionId, inputName) {
          const inputNames = this.sessionGraphInputs.get(sessionId);
          if (!inputNames) {
            return false;
          }
          return inputNames.includes(inputName);
        }
        isGraphOutput(sessionId, outputName) {
          const outputNames = this.sessionGraphOutputs.get(sessionId);
          if (!outputNames) {
            return false;
          }
          return outputNames.includes(outputName);
        }
        isGraphInputOutputTypeSupported(sessionId, type, isInput = true) {
          const dataType = onnxDataTypeToWebnnDataType.get(tensorDataTypeStringToEnum(type));
          const opLimits = this.mlOpSupportLimitsBySessionId.get(sessionId);
          if (typeof dataType === "undefined") {
            return false;
          }
          if (isInput) {
            return !!opLimits?.input.dataTypes.includes(dataType);
          } else {
            return !!opLimits?.output.dataTypes.includes(dataType);
          }
        }
        flush() {
        }
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/types.ts
  var init_types = __esm({
    "web/lib/wasm/jsep/webgpu/types.ts"() {
      "use strict";
    }
  });

  // web/lib/wasm/jsep/webgpu/gpu-data-manager.ts
  var bucketFreelist, bucketArr, calcNormalizedBufferSize, calcBucketBufferSize, guid, createNewGpuDataId, downloadGpuData, GpuDataManagerImpl, createGpuDataManager;
  var init_gpu_data_manager = __esm({
    "web/lib/wasm/jsep/webgpu/gpu-data-manager.ts"() {
      "use strict";
      init_log();
      init_types();
      bucketFreelist = /* @__PURE__ */ new Map([
        [64, 250],
        [128, 200],
        [256, 200],
        [512, 200],
        [2048, 230],
        [4096, 200],
        [8192, 50],
        [16384, 50],
        [32768, 50],
        [65536, 50],
        [131072, 50],
        [262144, 50],
        [524288, 50],
        [1048576, 50],
        [2097152, 30],
        [4194304, 20],
        [8388608, 10],
        [12582912, 10],
        [16777216, 10],
        [26214400, 15],
        [33554432, 22],
        [44236800, 2],
        [58982400, 6],
        // we don't want to cache the bucket sizes below but not caching them
        // results in some major performance hits for models like sd-turbo.
        [67108864, 6],
        [134217728, 6],
        [167772160, 6]
      ]);
      bucketArr = [];
      calcNormalizedBufferSize = (size) => Math.ceil(Number(size) / 16) * 16;
      calcBucketBufferSize = (size) => {
        for (let idx = 0; idx < bucketArr.length; idx++) {
          const sizeForBucket = bucketArr[idx];
          if (size <= sizeForBucket) {
            return sizeForBucket;
          }
        }
        return Math.ceil(size / 16) * 16;
      };
      guid = 1;
      createNewGpuDataId = () => guid++;
      downloadGpuData = async (backend, gpuBuffer, originalSize, getTargetBuffer) => {
        const bufferSize = calcNormalizedBufferSize(originalSize);
        const gpuReadBuffer = backend.device.createBuffer(
          // eslint-disable-next-line no-bitwise
          { size: bufferSize, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ }
        );
        try {
          const commandEncoder = backend.getCommandEncoder();
          backend.endComputePass();
          commandEncoder.copyBufferToBuffer(
            gpuBuffer,
            0,
            gpuReadBuffer,
            0,
            bufferSize
          );
          backend.flush();
          await gpuReadBuffer.mapAsync(GPUMapMode.READ);
          const arrayBuffer = gpuReadBuffer.getMappedRange();
          if (getTargetBuffer) {
            const targetBuffer = getTargetBuffer();
            targetBuffer.set(new Uint8Array(arrayBuffer, 0, originalSize));
            return targetBuffer;
          } else {
            return new Uint8Array(arrayBuffer.slice(0, originalSize));
          }
        } finally {
          gpuReadBuffer.destroy();
        }
      };
      GpuDataManagerImpl = class {
        constructor(backend) {
          this.backend = backend;
          this.storageCache = /* @__PURE__ */ new Map();
          this.freeBuffers = /* @__PURE__ */ new Map();
          this.freeUniformBuffers = /* @__PURE__ */ new Map();
          this.buffersPending = [];
          this.capturedPendingBuffers = /* @__PURE__ */ new Map();
          for (const [key] of bucketFreelist) {
            bucketArr.push(key);
            this.freeBuffers.set(key, []);
            this.freeUniformBuffers.set(key, []);
          }
          this.sessionCount = 0;
        }
        upload(id, data) {
          const srcArrayBuffer = data.buffer;
          const srcOffset = data.byteOffset;
          const srcLength = data.byteLength;
          const size = calcNormalizedBufferSize(srcLength);
          const gpuDataCache = this.storageCache.get(id);
          if (!gpuDataCache) {
            throw new Error("gpu data for uploading does not exist");
          }
          if (Number(gpuDataCache.originalSize) !== srcLength) {
            throw new Error(`inconsistent data size. gpu data size=${gpuDataCache.originalSize}, data size=${srcLength}`);
          }
          const gpuBufferForUploading = this.backend.device.createBuffer(
            // eslint-disable-next-line no-bitwise
            { mappedAtCreation: true, size, usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC }
          );
          const arrayBuffer = gpuBufferForUploading.getMappedRange();
          new Uint8Array(arrayBuffer).set(new Uint8Array(srcArrayBuffer, srcOffset, srcLength));
          gpuBufferForUploading.unmap();
          const commandEncoder = this.backend.device.createCommandEncoder();
          commandEncoder.copyBufferToBuffer(gpuBufferForUploading, 0, gpuDataCache.gpuData.buffer, 0, size);
          this.backend.device.queue.submit([commandEncoder.finish()]);
          gpuBufferForUploading.destroy();
          LOG_DEBUG("verbose", () => `[WebGPU] GpuDataManager.upload(id=${id})`);
        }
        memcpy(sourceId, destinationId) {
          const sourceGpuDataCache = this.storageCache.get(sourceId);
          if (!sourceGpuDataCache) {
            throw new Error("source gpu data for memcpy does not exist");
          }
          const destinationGpuDataCache = this.storageCache.get(destinationId);
          if (!destinationGpuDataCache) {
            throw new Error("destination gpu data for memcpy does not exist");
          }
          if (sourceGpuDataCache.originalSize !== destinationGpuDataCache.originalSize) {
            throw new Error("inconsistent source and destination gpu data size");
          }
          const size = calcNormalizedBufferSize(sourceGpuDataCache.originalSize);
          const commandEncoder = this.backend.getCommandEncoder();
          this.backend.endComputePass();
          commandEncoder.copyBufferToBuffer(
            sourceGpuDataCache.gpuData.buffer,
            0,
            destinationGpuDataCache.gpuData.buffer,
            0,
            size
          );
        }
        registerExternalBuffer(buffer, originalSize, previous) {
          let id;
          if (previous) {
            id = previous[0];
            if (buffer === previous[1]) {
              LOG_DEBUG(
                "verbose",
                () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${id}, buffer is the same, skip.`
              );
              return id;
            } else if (this.backend.capturedCommandList.has(this.backend.currentSessionId)) {
              throw new Error(`Registering a different external buffer under graph capture mode is not supported yet.
             Please use the previous external buffer!`);
            }
          } else {
            id = createNewGpuDataId();
          }
          this.storageCache.set(id, { gpuData: { id, type: 0 /* default */, buffer }, originalSize });
          LOG_DEBUG(
            "verbose",
            () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${id}, registered.`
          );
          return id;
        }
        unregisterExternalBuffer(id) {
          if (id !== void 0) {
            this.storageCache.delete(id);
            LOG_DEBUG("verbose", () => `[WebGPU] GpuDataManager.unregisterExternalBuffer() => id=${id}`);
          }
        }
        // eslint-disable-next-line no-bitwise
        create(size, usage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST) {
          const bufferSize = calcBucketBufferSize(size);
          let gpuBuffer;
          const isStorage = (usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE;
          const isUniform = (usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM;
          if (isStorage || isUniform) {
            const freeBuffers = isStorage ? this.freeBuffers : this.freeUniformBuffers;
            const buffers = freeBuffers.get(bufferSize);
            if (!buffers) {
              gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage });
            } else {
              if (buffers.length > 0) {
                gpuBuffer = buffers.pop();
              } else {
                gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage });
              }
            }
          } else {
            gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage });
          }
          const gpuData = { id: createNewGpuDataId(), type: 0 /* default */, buffer: gpuBuffer };
          this.storageCache.set(gpuData.id, { gpuData, originalSize: Number(size) });
          LOG_DEBUG("verbose", () => `[WebGPU] GpuDataManager.create(size=${size}) => id=${gpuData.id}`);
          return gpuData;
        }
        get(id) {
          return this.storageCache.get(id)?.gpuData;
        }
        release(idInput) {
          const id = typeof idInput === "bigint" ? Number(idInput) : idInput;
          const cachedData = this.storageCache.get(id);
          if (!cachedData) {
            if (this.storageCache.size === 0) {
              return 0;
            } else {
              throw new Error("releasing data does not exist");
            }
          }
          LOG_DEBUG("verbose", () => `[WebGPU] GpuDataManager.release(id=${id}), gpuDataId=${cachedData.gpuData.id}`);
          this.storageCache.delete(id);
          this.buffersPending.push(cachedData.gpuData.buffer);
          return cachedData.originalSize;
        }
        async download(id, getTargetBuffer) {
          const cachedData = this.storageCache.get(Number(id));
          if (!cachedData) {
            throw new Error("data does not exist");
          }
          await downloadGpuData(this.backend, cachedData.gpuData.buffer, cachedData.originalSize, getTargetBuffer);
        }
        refreshPendingBuffers() {
          if (this.buffersPending.length === 0) {
            return;
          }
          if (this.backend.sessionStatus === "default") {
            for (const buffer of this.buffersPending) {
              const maxInFreeList = bucketFreelist.get(buffer.size);
              if ((buffer.usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE) {
                const freelist = this.freeBuffers.get(buffer.size) || [];
                if (maxInFreeList === void 0 || freelist.length >= maxInFreeList) {
                  buffer.destroy();
                } else {
                  freelist.push(buffer);
                }
              } else if ((buffer.usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM) {
                const freelist = this.freeUniformBuffers.get(buffer.size) || [];
                if (maxInFreeList === void 0 || freelist.length >= maxInFreeList) {
                  buffer.destroy();
                } else {
                  freelist.push(buffer);
                }
              } else {
                buffer.destroy();
              }
            }
            this.buffersPending = [];
          } else {
            let capturedBuffers = this.capturedPendingBuffers.get(this.backend.currentSessionId);
            if (!capturedBuffers) {
              capturedBuffers = [];
              this.capturedPendingBuffers.set(this.backend.currentSessionId, capturedBuffers);
            }
            for (const buffer of this.buffersPending) {
              capturedBuffers.push(buffer);
            }
            this.buffersPending = [];
          }
        }
        dispose() {
          this.freeBuffers.forEach((buffers) => {
            buffers.forEach((buffer) => {
              buffer.destroy();
            });
          });
          this.freeUniformBuffers.forEach((buffers) => {
            buffers.forEach((buffer) => {
              buffer.destroy();
            });
          });
          this.storageCache.forEach((storage) => {
            storage.gpuData.buffer.destroy();
          });
          this.capturedPendingBuffers.forEach((buffers) => {
            buffers.forEach((buffer) => {
              buffer.destroy();
            });
          });
          this.storageCache = /* @__PURE__ */ new Map();
          this.freeBuffers = /* @__PURE__ */ new Map();
          this.freeUniformBuffers = /* @__PURE__ */ new Map();
          this.capturedPendingBuffers = /* @__PURE__ */ new Map();
        }
        onCreateSession() {
          this.sessionCount += 1;
        }
        onReleaseSession(sessionId) {
          const pendingBuffers = this.capturedPendingBuffers.get(sessionId);
          if (pendingBuffers) {
            pendingBuffers.forEach((buffer) => {
              buffer.destroy();
            });
            this.capturedPendingBuffers.delete(sessionId);
          }
          this.sessionCount -= 1;
          if (this.sessionCount === 0) {
            LOG_DEBUG("warning", () => "[WebGPU] Clearing webgpu buffer cache");
            this.storageCache.forEach((storage) => {
              storage.gpuData.buffer.destroy();
            });
            this.storageCache = /* @__PURE__ */ new Map();
          }
        }
      };
      createGpuDataManager = (...args) => new GpuDataManagerImpl(...args);
    }
  });

  // web/lib/wasm/jsep/webgpu/attribute-with-cache-key.ts
  var AttributeWithCacheKeyImpl, createAttributeWithCacheKey;
  var init_attribute_with_cache_key = __esm({
    "web/lib/wasm/jsep/webgpu/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((name) => `${this[name]}`).join(";");
          }
          return this.key;
        }
      };
      createAttributeWithCacheKey = (attribute) => new AttributeWithCacheKeyImpl(attribute);
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/common.ts
  var WORKGROUP_SIZE, getWgslMappedType, tensorTypeToWsglStorageType, tensorTypeToWsglValueType, createTensorShapeVariables, getMaxComponents, fillVector, castToF32, sumVector, getElementAt, createIndicesHelper, inputVariable, outputVariable, atomicOutputVariable, internalVariable, ShaderHelperImpl, createShaderHelper;
  var init_common = __esm({
    "web/lib/wasm/jsep/webgpu/ops/common.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      WORKGROUP_SIZE = 64;
      getWgslMappedType = (type, components) => {
        if (components === 3) {
          throw new Error("vec3 has same alignment as vec4, use vec4 instead");
        }
        switch (Number(type)) {
          case 10 /* float16 */:
            return components > 1 ? `vec${components}<f16>` : "f16";
          case 1 /* float */:
            return components > 1 ? `vec${components}<f32>` : "f32";
          case 6 /* int32 */:
            return components > 1 ? `vec${components}<i32>` : "i32";
          case 12 /* uint32 */:
            return components > 1 ? `vec${components}<u32>` : "u32";
          case 7 /* int64 */:
            if (components > 1) {
              throw new Error("currently not supported vecX of uint64 yet");
            }
            return ["vec2<u32>", "i32"];
          case 13 /* uint64 */:
            if (components > 1) {
              throw new Error("currently not supported vecX of uint64 yet");
            }
            return ["vec2<u32>", "u32"];
          case 9 /* bool */:
            if (components !== 4) {
              throw new Error("bool must be vec4");
            }
            return ["u32", "vec4<bool>"];
          case 22 /* int4 */:
            return "i32";
          case 21 /* uint4 */:
            return "u32";
          default:
            throw new Error(`Unknown data type: ${type}`);
        }
      };
      tensorTypeToWsglStorageType = (type, components = 1) => {
        const mappedType = getWgslMappedType(type, components);
        return typeof mappedType === "string" ? mappedType : mappedType[0];
      };
      tensorTypeToWsglValueType = (type, components = 1) => {
        const mappedType = getWgslMappedType(type, components);
        return typeof mappedType === "string" ? mappedType : mappedType[1];
      };
      createTensorShapeVariables = (...dims) => {
        const programUniforms = [];
        dims.forEach((dim) => {
          if (dim.length !== 0) {
            programUniforms.push(
              { type: 12 /* uint32 */, data: dim },
              { type: 12 /* uint32 */, data: ShapeUtil.computeStrides(dim) }
            );
          }
        });
        return programUniforms;
      };
      getMaxComponents = (size) => {
        if (size % 4 === 0) {
          return 4;
        } else if (size % 2 === 0) {
          return 2;
        }
        return 1;
      };
      fillVector = (dataType = "f32", components, value = "0") => {
        if (!components || components === 1) {
          return `${dataType}(${value})`;
        }
        return `vec${components}<${dataType}>(${value})`;
      };
      castToF32 = (dataType, components, value) => {
        if (dataType === "f32") {
          return value;
        }
        if (components === 1) {
          return `f32(${value})`;
        }
        return `vec${components}<f32>(${value})`;
      };
      sumVector = (name, components) => {
        if (components === 4) {
          return `(${name}.x + ${name}.y + ${name}.z + ${name}.w)`;
        } else if (components === 2) {
          return `(${name}.x + ${name}.y)`;
        } else if (components === 3) {
          return `(${name}.x + ${name}.y + ${name}.z)`;
        }
        return name;
      };
      getElementAt = (name, index, length, type) => {
        if (name.startsWith("uniforms.") && length > 4) {
          if (typeof index === "string") {
            if (type === "f16") {
              return `${name}[(${index}) / 8][(${index}) % 8 / 4][(${index}) % 8 % 4]`;
            } else {
              return `${name}[(${index}) / 4][(${index}) % 4]`;
            }
          } else {
            if (type === "f16") {
              return `${name}[${Math.floor(index / 8)}][${Math.floor(index % 8 / 4)}][${index % 8 % 4}]`;
            } else {
              return `${name}[${Math.floor(index / 4)}][${index % 4}]`;
            }
          }
        } else {
          return length > 1 ? `${name}[${index}]` : name;
        }
      };
      createIndicesHelper = (name, tensorType, shapeOrRank, usage, components) => {
        const useUniform = typeof shapeOrRank === "number";
        const rank = useUniform ? shapeOrRank : shapeOrRank.length;
        const rankIdentity = [...new Array(rank).keys()];
        const indicesType = rank < 2 ? "u32" : rank <= 4 ? `vec${rank}<u32>` : `array<u32, ${rank}>`;
        const mappedType = getWgslMappedType(tensorType, components);
        const valueType = typeof mappedType === "string" ? mappedType : mappedType[1];
        const storageType = typeof mappedType === "string" ? mappedType : mappedType[0];
        const type = { indices: indicesType, value: valueType, storage: storageType, tensor: tensorType };
        const normalizeDim = (dim) => typeof dim === "string" ? dim : `${dim}u`;
        const implementationUsed = {
          offsetToIndices: false,
          indicesToOffset: false,
          broadcastedIndicesToOffset: false,
          set: false,
          setByIndices: false,
          get: false,
          getByIndices: false
        };
        const uniformPrefix = useUniform ? "uniforms." : "";
        const shape = `${uniformPrefix}${name}_shape`;
        const strides = `${uniformPrefix}${name}_strides`;
        let o2iSnippet = "";
        for (let i = 0; i < rank - 1; i++) {
          o2iSnippet += `
    let dim${i} = current / ${getElementAt(strides, i, rank)};
    let rest${i} = current % ${getElementAt(strides, i, rank)};
    indices[${i}] = dim${i};
    current = rest${i};
    `;
        }
        o2iSnippet += `indices[${rank - 1}] = current;`;
        const offsetToIndicesImplementation = rank < 2 ? "" : `
  fn o2i_${name}(offset: u32) -> ${type.indices} {
    var indices: ${type.indices};
    var current = offset;
    ${o2iSnippet}
    return indices;
  }`;
        const offsetToIndices = (varOffset) => {
          implementationUsed.offsetToIndices = true;
          return rank < 2 ? varOffset : `o2i_${name}(${varOffset})`;
        };
        const offsets = [];
        if (rank >= 2) {
          for (let i = rank - 1; i >= 0; i--) {
            offsets.push(`${getElementAt(strides, i, rank)} * (indices[${i}])`);
          }
        }
        const indicesToOffsetImplementation = rank < 2 ? "" : `
  fn i2o_${name}(indices: ${type.indices}) -> u32 {
    return ${offsets.join("+")};
  }`;
        const indicesToOffset = (varIndices) => {
          implementationUsed.indicesToOffset = true;
          return rank < 2 ? varIndices : `i2o_${name}(${varIndices})`;
        };
        const indices = (...init2) => rank === 0 ? "0u" : `${type.indices}(${init2.map(normalizeDim).join(",")})`;
        const indicesGet = (varIndices, idx) => {
          if (rank < 2) {
            return `${varIndices}`;
          } else {
            return `${getElementAt(varIndices, idx, rank)}`;
          }
        };
        const indicesSet = (varIndices, idx, value) => {
          if (rank < 2) {
            return `${varIndices}=${value};`;
          } else {
            return `${getElementAt(varIndices, idx, rank)}=${value};`;
          }
        };
        const broadcastedIndicesToOffsetImplementation = {};
        const broadcastedIndicesToOffset = (varIndices, output) => {
          implementationUsed.broadcastedIndicesToOffset = true;
          const implKey = `${output.name}broadcastedIndicesTo${name}Offset`;
          if (implKey in broadcastedIndicesToOffsetImplementation) {
            return `${implKey}(${varIndices})`;
          }
          const offsets2 = [];
          for (let i = rank - 1; i >= 0; i--) {
            const idx = output.indicesGet("outputIndices", i + output.rank - rank);
            offsets2.push(`${indicesGet(strides, i)} * (${idx} % ${indicesGet(shape, i)})`);
          }
          broadcastedIndicesToOffsetImplementation[implKey] = `fn ${implKey}(outputIndices: ${output.type.indices}) -> u32 {
             return ${offsets2.length > 0 ? offsets2.join("+") : "0u"};
           }`;
          return `${implKey}(${varIndices})`;
        };
        const setByOffset = (offset, value) => (() => {
          if (type.storage === type.value) {
            return `${name}[${offset}]=${value};`;
          } else if (type.storage === "vec2<u32>" && type.value === "i32") {
            return `${name}[${offset}]=vec2<u32>(u32(${value}), select(0u, 0xFFFFFFFFu, ${value} < 0));`;
          } else if (type.storage === "vec2<u32>" && type.value === "u32") {
            return `${name}[${offset}]=vec2<u32>(u32(${value}), 0u);`;
          } else if (type.storage === "u32" && type.value === "vec4<bool>") {
            return `${name}[${offset}]=dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(${value}));`;
          } else {
            throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`);
          }
        })();
        const getByOffset = (offset) => (() => {
          if (type.storage === type.value) {
            return `${name}[${offset}]`;
          } else if (type.storage === "vec2<u32>" && type.value === "i32") {
            return `i32(${name}[${offset}].x)`;
          } else if (type.storage === "vec2<u32>" && type.value === "u32") {
            return `u32(${name}[${offset}].x)`;
          } else if (type.storage === "u32" && type.value === "vec4<bool>") {
            return `vec4<bool>(bool(${name}[${offset}] & 0xFFu), bool(${name}[${offset}] & 0xFF00u), bool(${name}[${offset}] & 0xFF0000u), bool(${name}[${offset}] & 0xFF000000u))`;
          } else {
            throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`);
          }
        })();
        const getByIndicesImplementation = rank < 2 ? "" : `
  fn get_${name}ByIndices(indices: ${type.indices}) -> ${valueType} {
    return ${getByOffset(`i2o_${name}(indices)`)};
  }`;
        const getImplementation = rank < 2 ? "" : (() => {
          const functionParams = rankIdentity.map((i) => `d${i}: u32`).join(", ");
          const dimsParams = rankIdentity.map((i) => `d${i}`).join(", ");
          return `
  fn get_${name}(${functionParams}) -> ${valueType} {
    return get_${name}ByIndices(${indices(dimsParams)});
  }`;
        })();
        const get = (...indices2) => {
          if (indices2.length !== rank) {
            throw new Error(`indices length must be ${rank}`);
          }
          const normalizedIndices = indices2.map(normalizeDim).join(",");
          if (rank === 0) {
            return getByOffset("0u");
          } else if (rank === 1) {
            return getByOffset(normalizedIndices[0]);
          } else {
            implementationUsed.get = true;
            implementationUsed.getByIndices = true;
            implementationUsed.indicesToOffset = true;
            return `get_${name}(${normalizedIndices})`;
          }
        };
        const getByIndices = (varIndices) => {
          if (rank < 2) {
            return getByOffset(varIndices);
          } else {
            implementationUsed.getByIndices = true;
            implementationUsed.indicesToOffset = true;
            return `get_${name}ByIndices(${varIndices})`;
          }
        };
        const setByIndicesImplementation = rank < 2 ? "" : `
  fn set_${name}ByIndices(indices: ${type.indices}, value: ${valueType}) {
    ${setByOffset(`i2o_${name}(indices)`, "value")}
  }`;
        const setImplementation = rank < 2 ? "" : (() => {
          const functionParams = rankIdentity.map((i) => `d${i}: u32`).join(", ");
          const dimsParams = rankIdentity.map((i) => `d${i}`).join(", ");
          return `
  fn set_${name}(${functionParams}, value: ${valueType}) {
    set_${name}ByIndices(${indices(dimsParams)}, value);
  }`;
        })();
        const set = (...indicesAndValue) => {
          if (indicesAndValue.length !== rank + 1) {
            throw new Error(`indices length must be ${rank}`);
          }
          const value = indicesAndValue[rank];
          if (typeof value !== "string") {
            throw new Error("value must be string");
          }
          const normalizedIndices = indicesAndValue.slice(0, rank).map(normalizeDim).join(",");
          if (rank === 0) {
            return setByOffset("0u", value);
          } else if (rank === 1) {
            return setByOffset(normalizedIndices[0], value);
          } else {
            implementationUsed.set = true;
            implementationUsed.setByIndices = true;
            implementationUsed.indicesToOffset = true;
            return `set_${name}(${normalizedIndices}, ${value})`;
          }
        };
        const setByIndices = (varIndices, value) => {
          if (rank < 2) {
            return setByOffset(varIndices, value);
          } else {
            implementationUsed.setByIndices = true;
            implementationUsed.indicesToOffset = true;
            return `set_${name}ByIndices(${varIndices}, ${value});`;
          }
        };
        const impl = () => {
          const impls = [];
          let needShapeStrides = false;
          if (implementationUsed.offsetToIndices) {
            impls.push(offsetToIndicesImplementation);
            needShapeStrides = true;
          }
          if (implementationUsed.indicesToOffset) {
            impls.push(indicesToOffsetImplementation);
            needShapeStrides = true;
          }
          if (implementationUsed.broadcastedIndicesToOffset) {
            Object.values(broadcastedIndicesToOffsetImplementation).forEach((impl2) => impls.push(impl2));
            needShapeStrides = true;
          }
          if (implementationUsed.set) {
            impls.push(setImplementation);
            needShapeStrides = true;
          }
          if (implementationUsed.setByIndices) {
            impls.push(setByIndicesImplementation);
            needShapeStrides = true;
          }
          if (implementationUsed.get) {
            impls.push(getImplementation);
            needShapeStrides = true;
          }
          if (implementationUsed.getByIndices) {
            impls.push(getByIndicesImplementation);
            needShapeStrides = true;
          }
          if (!useUniform && needShapeStrides) {
            impls.unshift(
              `const ${shape} = ${type.indices}(${shapeOrRank.join(",")});`,
              `const ${strides} = ${type.indices}(${ShapeUtil.computeStrides(shapeOrRank).join(",")});`
            );
          }
          return impls.join("\n");
        };
        return {
          impl,
          type,
          offsetToIndices,
          indicesToOffset,
          broadcastedIndicesToOffset,
          indices,
          indicesGet,
          indicesSet,
          set,
          setByOffset,
          setByIndices,
          get,
          getByOffset,
          getByIndices,
          // isVec4,
          usage,
          name,
          strides,
          shape,
          rank
        };
      };
      inputVariable = (name, type, shapeOrRank, components = 1) => createIndicesHelper(name, type, shapeOrRank, "input", components);
      outputVariable = (name, type, shapeOrRank, components = 1) => createIndicesHelper(name, type, shapeOrRank, "output", components);
      atomicOutputVariable = (name, type, shapeOrRank) => createIndicesHelper(name, type, shapeOrRank, "atomicOutput", 1);
      internalVariable = (name, type, shapeOrRank, components = 1) => createIndicesHelper(name, type, shapeOrRank, "internal", components);
      ShaderHelperImpl = class {
        constructor(normalizedDispatchGroup, limits) {
          this.normalizedDispatchGroup = normalizedDispatchGroup;
          this.limits = limits;
          this.internalVariables = [];
          this.variables = [];
          this.uniforms = [];
          this.variableIndex = 0;
        }
        guardAgainstOutOfBoundsWorkgroupSizes(size) {
          const sizeInCode = typeof size === "number" ? `${size}u` : size;
          return `if (global_idx >= ${sizeInCode}) { return; }`;
        }
        mainStart(workgroupSize = WORKGROUP_SIZE) {
          const workgroupSizeX = typeof workgroupSize === "number" ? workgroupSize : workgroupSize[0];
          const workgroupSizeY = typeof workgroupSize === "number" ? 1 : workgroupSize[1];
          const workgroupSizeZ = typeof workgroupSize === "number" ? 1 : workgroupSize[2];
          if (workgroupSizeX > this.limits.maxComputeWorkgroupSizeX || workgroupSizeY > this.limits.maxComputeWorkgroupSizeY || workgroupSizeZ > this.limits.maxComputeWorkgroupSizeZ) {
            throw new Error(
              `workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ}] exceeds the maximum workgroup size [${this.limits.maxComputeWorkgroupSizeX}, ${this.limits.maxComputeWorkgroupSizeY}, ${this.limits.maxComputeWorkgroupSizeZ}].`
            );
          }
          if (workgroupSizeX * workgroupSizeY * workgroupSizeZ > this.limits.maxComputeInvocationsPerWorkgroup) {
            throw new Error(
              `workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ}] exceeds the maximum workgroup invocations ${this.limits.maxComputeInvocationsPerWorkgroup}.`
            );
          }
          const is1DimensionDispatch = this.normalizedDispatchGroup[1] === 1 && this.normalizedDispatchGroup[2] === 1;
          const paramList = is1DimensionDispatch ? `@builtin(global_invocation_id) global_id : vec3<u32>,
    @builtin(workgroup_id) workgroup_id : vec3<u32>,
    @builtin(local_invocation_index) local_idx : u32,
    @builtin(local_invocation_id) local_id : vec3<u32>` : `@builtin(global_invocation_id) global_id : vec3<u32>,
                                             @builtin(local_invocation_id) local_id : vec3<u32>,
    @builtin(local_invocation_index) local_idx : u32,
    @builtin(workgroup_id) workgroup_id : vec3<u32>,
    @builtin(num_workgroups) num_workgroups : vec3<u32>`;
          const globalIdxDefinition = is1DimensionDispatch ? `let global_idx = global_id.x;
         let workgroup_index = workgroup_id.x;` : `let workgroup_index = workgroup_id.z * num_workgroups[0] * num_workgroups[1] +
             workgroup_id.y * num_workgroups[0] + workgroup_id.x;
         let global_idx = workgroup_index * ${workgroupSizeX * workgroupSizeY * workgroupSizeZ}u + local_idx;`;
          return `@compute @workgroup_size(${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ})
  fn main(${paramList}) {
    ${globalIdxDefinition}
  `;
        }
        appendVariableUniforms(variable) {
          if (variable.rank !== 0) {
            if (variable.shape.startsWith("uniforms.")) {
              this.uniforms.push({ name: variable.shape.replace("uniforms.", ""), type: "u32", length: variable.rank });
            }
            if (variable.strides.startsWith("uniforms.")) {
              this.uniforms.push({ name: variable.strides.replace("uniforms.", ""), type: "u32", length: variable.rank });
            }
          }
        }
        declareVariable(variable, bindingIndex) {
          if (variable.usage === "internal") {
            throw new Error("cannot use internal variable with declareVariable(). use registerInternalVariables() instead.");
          }
          this.variables.push(variable);
          this.appendVariableUniforms(variable);
          const access = variable.usage === "input" ? "read" : "read_write";
          const storageType = variable.usage === "atomicOutput" ? `atomic<i32>` : variable.type.storage;
          return `@group(0) @binding(${bindingIndex}) var<storage, ${access}> ${variable.name}: array<${storageType}>;`;
        }
        declareVariables(...variables) {
          return variables.map((v) => this.declareVariable(v, this.variableIndex++)).join("\n");
        }
        registerInternalVariable(variable) {
          if (variable.usage !== "internal") {
            throw new Error(
              "cannot use input or output variable with registerInternalVariable(). use declareVariables() instead."
            );
          }
          this.internalVariables.push(variable);
          this.appendVariableUniforms(variable);
        }
        registerInternalVariables(...variables) {
          variables.forEach((v) => this.registerInternalVariable(v));
          return this;
        }
        registerUniform(name, type, length = 1) {
          this.uniforms.push({ name, type, length });
          return this;
        }
        registerUniforms(additionalUniforms) {
          this.uniforms = this.uniforms.concat(additionalUniforms);
          return this;
        }
        uniformDeclaration() {
          if (this.uniforms.length === 0) {
            return "";
          }
          const uniformSnippets = [];
          for (const { name, type, length } of this.uniforms) {
            if (length && length > 4) {
              if (type === "f16") {
                uniformSnippets.push(`@align(16) ${name}:array<mat2x4<${type}>, ${Math.ceil(length / 8)}>`);
              } else {
                uniformSnippets.push(`${name}:array<vec4<${type}>, ${Math.ceil(length / 4)}>`);
              }
            } else {
              const typeTemp = length == null || length === 1 ? type : `vec${length}<${type}>`;
              uniformSnippets.push(`${name}:${typeTemp}`);
            }
          }
          return `
      struct Uniforms { ${uniformSnippets.join(", ")} };
      @group(0) @binding(${this.variableIndex}) var<uniform> uniforms: Uniforms;`;
        }
        /**
         * Get additional implementation that needs to be added to the shader source.
         */
        get additionalImplementations() {
          return this.uniformDeclaration() + this.variables.map((i) => i.impl()).join("\n") + this.internalVariables.map((i) => i.impl()).join("\n");
        }
        /**
         * Get the variable info of the shader program.
         */
        get variablesInfo() {
          if (this.uniforms.length === 0) {
            return void 0;
          }
          const uniformWgslTypeToDataType = (type) => [12 /* uint32 */, 10 /* float16 */, 1 /* float */, 6 /* int32 */][["u32", "f16", "f32", "i32"].indexOf(type)];
          return this.uniforms.map((u) => [uniformWgslTypeToDataType(u.type), u.length ?? 1]);
        }
      };
      createShaderHelper = (dispatchGroup, limits) => new ShaderHelperImpl(dispatchGroup, limits);
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/transpose.ts
  var validateInputs, getAdjustedPerm, getOutputShape, permFunctionBody, squeezeShape, isTransposeReshape, createTransposeProgramInfo, transpose, parseTransposeAttributes;
  var init_transpose = __esm({
    "web/lib/wasm/jsep/webgpu/ops/transpose.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      validateInputs = (inputs, perm) => {
        if (!inputs || inputs.length !== 1) {
          throw new Error("Transpose requires 1 input.");
        }
        if (perm.length !== 0 && perm.length !== inputs[0].dims.length) {
          throw new Error(`perm size ${perm.length} does not match input rank ${inputs[0].dims.length}`);
        }
      };
      getAdjustedPerm = (inputRank, perm) => perm.length !== 0 ? perm : [...new Array(inputRank).keys()].reverse();
      getOutputShape = (inputShape, perm) => ShapeUtil.sortBasedOnPerm(inputShape, getAdjustedPerm(inputShape.length, perm));
      permFunctionBody = (perm, rank, input, output) => {
        let reverseFunc = `fn perm(i: ${output.type.indices}) -> ${input.type.indices} {
    var a: ${input.type.indices};`;
        for (let i = 0; i < rank; ++i) {
          reverseFunc += `a[${perm[i]}]=i[${i}];`;
        }
        return reverseFunc += "return a;}";
      };
      squeezeShape = (shape, adjustedPerm) => {
        const newShape = [];
        const newPerm = [];
        for (let i = 0; i < shape.length; ++i) {
          if (shape[i] !== 1) {
            newShape.push(shape[i]);
          }
          if (shape[adjustedPerm[i]] !== 1) {
            newPerm.push(adjustedPerm[i]);
          }
        }
        return { newShape, newPerm };
      };
      isTransposeReshape = (perm, shape) => {
        let lastPermutedAxis = 0;
        for (let i = 0; i < perm.length; ++i) {
          if (shape[perm[i]] === 1) {
            continue;
          }
          if (perm[i] < lastPermutedAxis) {
            return false;
          }
          lastPermutedAxis = perm[i];
        }
        return true;
      };
      createTransposeProgramInfo = (inputTensor, permAttr) => {
        const inputDataType = inputTensor.dataType;
        const inputRank = inputTensor.dims.length;
        const perm = getAdjustedPerm(inputRank, permAttr);
        const outputShape = getOutputShape(inputTensor.dims, perm);
        let newInputShape = inputTensor.dims;
        let newOutputShape = outputShape;
        const transposeAsReshape = inputRank < 2 || isTransposeReshape(perm, inputTensor.dims);
        let getShaderSource;
        if (transposeAsReshape) {
          getShaderSource = (shaderHelper) => {
            const input = inputVariable("input", inputDataType, newInputShape, 4);
            const output = outputVariable("output", inputDataType, newOutputShape, 4);
            return `
  ${shaderHelper.registerUniform("output_size", "u32").declareVariables(input, output)}
  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
    output[global_idx] = input[global_idx];
  }`;
          };
          return {
            name: "TransposeCopy",
            shaderCache: { inputDependencies: ["type"] },
            getRunData: () => {
              const outputSize = ShapeUtil.size(outputShape);
              return {
                outputs: [{ dims: outputShape, dataType: inputTensor.dataType }],
                dispatchGroup: { x: Math.ceil(
                  outputSize / 64 / 4
                  /* components */
                ) },
                programUniforms: [{ type: 12 /* uint32 */, data: Math.ceil(outputSize / 4) }]
              };
            },
            getShaderSource
          };
        }
        const { newShape, newPerm } = squeezeShape(inputTensor.dims, perm);
        const channelsLast = ShapeUtil.areEqual(newPerm, [2, 3, 1]);
        const channelsFirst = ShapeUtil.areEqual(newPerm, [3, 1, 2]);
        const useShared = newShape.length === 2 || channelsLast || channelsFirst;
        if (useShared) {
          newInputShape = channelsLast ? [newShape[0], newShape[1] * newShape[2]] : channelsFirst ? [newShape[0] * newShape[1], newShape[2]] : newShape;
          newOutputShape = [newInputShape[1], newInputShape[0]];
          const tileSize = 16;
          getShaderSource = (shaderHelper) => {
            const input = inputVariable("a", inputDataType, newInputShape.length);
            const output = outputVariable("output", inputDataType, newOutputShape.length);
            return `
  ${shaderHelper.registerUniform("output_size", "u32").declareVariables(input, output)}
  var<workgroup> tile : array<array<${output.type.value}, ${tileSize + 1}>, ${tileSize}>;
  ${shaderHelper.mainStart([tileSize, tileSize, 1])}
    let stride = (uniforms.output_shape[1] - 1) / ${tileSize} + 1;
    let workgroup_id_x = workgroup_index % stride;
    let workgroup_id_y = workgroup_index / stride;
    let input_col = workgroup_id_y * ${tileSize}u + local_id.x;
    let input_row = workgroup_id_x * ${tileSize}u + local_id.y;
    if (input_row < uniforms.a_shape[0] && input_col < uniforms.a_shape[1]) {
      tile[local_id.y][local_id.x] = ${input.getByIndices(`${input.type.indices}(input_row, input_col)`)};
    }
    workgroupBarrier();

    let output_col = workgroup_id_x * ${tileSize}u + local_id.x;
    let output_row = workgroup_id_y * ${tileSize}u + local_id.y;
    if (output_row < uniforms.output_shape[0] && output_col < uniforms.output_shape[1]) {
      ${output.setByIndices(`${output.type.indices}(output_row, output_col)`, "tile[local_id.x][local_id.y]")}
    }
  }`;
          };
          return {
            name: "TransposeShared",
            shaderCache: { inputDependencies: ["type"] },
            getRunData: () => {
              const outputSize = ShapeUtil.size(outputShape);
              return {
                outputs: [{ dims: outputShape, dataType: inputTensor.dataType }],
                dispatchGroup: { x: Math.ceil(newOutputShape[1] / tileSize), y: Math.ceil(newOutputShape[0] / tileSize) },
                programUniforms: [
                  { type: 12 /* uint32 */, data: outputSize },
                  ...createTensorShapeVariables(newInputShape, newOutputShape)
                ]
              };
            },
            getShaderSource
          };
        }
        getShaderSource = (shaderHelper) => {
          const input = inputVariable("a", inputDataType, newInputShape.length);
          const output = outputVariable("output", inputDataType, newOutputShape.length);
          return `
  ${shaderHelper.registerUniform("output_size", "u32").declareVariables(input, output)}

  ${permFunctionBody(perm, inputRank, input, output)}

  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}

    let indices = ${output.offsetToIndices("global_idx")};
    let aIndices = perm(indices);

    ${output.setByOffset("global_idx", input.getByIndices("aIndices"))}
  }`;
        };
        return {
          name: "Transpose",
          shaderCache: { hint: `${permAttr}`, inputDependencies: ["rank"] },
          getRunData: () => {
            const outputSize = ShapeUtil.size(outputShape);
            return {
              outputs: [{ dims: outputShape, dataType: inputTensor.dataType }],
              dispatchGroup: { x: Math.ceil(
                outputSize / 64
                /* workgroup size */
              ) },
              programUniforms: [
                { type: 12 /* uint32 */, data: outputSize },
                ...createTensorShapeVariables(newInputShape, newOutputShape)
              ]
            };
          },
          getShaderSource
        };
      };
      transpose = (context, attributes) => {
        validateInputs(context.inputs, attributes.perm);
        context.compute(createTransposeProgramInfo(context.inputs[0], attributes.perm));
      };
      parseTransposeAttributes = (attributes) => createAttributeWithCacheKey({ perm: attributes.perm });
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/reduce-shared.ts
  var reduceOps, reduceSharedOps, reduceInitValues, reduceOutputValues, getInnerMostAxes, computeOutAndReduceShapes, expandShapeToKeepDim, areAxesInnerMostDims, getAxesPermutation, createReduceSharedProgramInfo, reduceCommon, reduceMeanShared, reduceL1Shared, reduceL2Shared, reduceLogSumExpShared, reduceMaxShared, reduceMinShared, reduceProdShared, reduceSumShared, reduceSumSquareShared, reduceLogSumShared;
  var init_reduce_shared = __esm({
    "web/lib/wasm/jsep/webgpu/ops/reduce-shared.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_common();
      init_reduce();
      init_transpose();
      reduceOps = {
        max: "select(bestValue, candidate, candidate > bestValue)",
        min: "select(bestValue, candidate, candidate < bestValue)",
        mean: "bestValue + candidate",
        sum: "bestValue + candidate",
        prod: "bestValue * candidate",
        sumSquare: "bestValue + candidate * candidate",
        logSumExp: "bestValue + exp(candidate)",
        l1: "bestValue + abs(candidate)",
        l2: "bestValue + candidate * candidate",
        logSum: "bestValue + candidate"
      };
      reduceSharedOps = {
        max: "select(bestValue, candidate, candidate > bestValue)",
        min: "select(bestValue, candidate, candidate < bestValue)",
        mean: "bestValue + candidate",
        sum: "bestValue + candidate",
        prod: "bestValue * candidate",
        sumSquare: "bestValue + candidate",
        logSumExp: "bestValue + candidate",
        l1: "bestValue + candidate",
        l2: "bestValue + candidate",
        logSum: "bestValue + candidate"
      };
      reduceInitValues = {
        max: "_A[offset]",
        min: "_A[offset]",
        mean: "0",
        sum: "0",
        prod: "1",
        sumSquare: "0",
        logSumExp: "0",
        l1: "0",
        l2: "0",
        logSum: "0"
      };
      reduceOutputValues = {
        max: "bestValue",
        min: "bestValue",
        sum: "bestValue",
        prod: "bestValue",
        sumSquare: "bestValue",
        logSumExp: "log(bestValue)",
        l1: "bestValue",
        l2: "sqrt(bestValue)",
        logSum: "log(bestValue)"
      };
      getInnerMostAxes = (numInnerAxes, rank) => {
        const res = [];
        for (let i = rank - numInnerAxes; i < rank; ++i) {
          res.push(i);
        }
        return res;
      };
      computeOutAndReduceShapes = (shape, axes) => {
        const outputShape = [];
        const rank = shape.length;
        for (let dim = 0; dim < rank; dim++) {
          if (axes.indexOf(dim) === -1) {
            outputShape.push(shape[dim]);
          }
        }
        const reduceShape = axes.map((dim) => shape[dim]);
        return [outputShape, reduceShape];
      };
      expandShapeToKeepDim = (shape, axes) => {
        const rank = shape.length + axes.length;
        const expandShape = [];
        let shapeIdx = 0;
        for (let dim = 0; dim < rank; dim++) {
          if (axes.indexOf(dim) === -1) {
            expandShape.push(shape[shapeIdx++]);
          } else {
            expandShape.push(1);
          }
        }
        return expandShape;
      };
      areAxesInnerMostDims = (axes, rank) => {
        for (let i = 0; i < axes.length; ++i) {
          if (axes[axes.length - i - 1] !== rank - 1 - i) {
            return false;
          }
        }
        return true;
      };
      getAxesPermutation = (axes, rank) => {
        const res = [];
        if (!areAxesInnerMostDims(axes, rank)) {
          for (let i = 0; i < rank; ++i) {
            if (axes.indexOf(i) === -1) {
              res.push(i);
            }
          }
          axes.forEach((axis) => res.push(axis));
        }
        return res;
      };
      createReduceSharedProgramInfo = (name, cacheKey, inputs, reduceType, outputDataType, outputShape, reduceShape) => {
        const inputShape = inputs[0].dims;
        const outputSize = ShapeUtil.size(outputShape);
        const reduceSize = ShapeUtil.size(reduceShape);
        const input = inputVariable("_A", inputs[0].dataType, inputShape);
        const output = outputVariable("output", outputDataType, outputShape);
        let workgroupSize = 64;
        if (outputSize === 1) {
          workgroupSize = 256;
        }
        const sharedMemorySnippet = `
          var<workgroup> aBestValues : array<f32, ${workgroupSize}>;
       `;
        const getShaderSource = (shaderHelper) => `
        ${shaderHelper.registerUniform("reduceSize", "u32").declareVariables(input, output)}
        ${sharedMemorySnippet}
        fn DIV_CEIL(a : u32, b : u32) -> u32 {
          return ((a - 1u) / b + 1u);
         }
         ${shaderHelper.mainStart(workgroupSize)}

          let outputIndex = global_idx / ${workgroupSize};
          let offset = outputIndex * uniforms.reduceSize;

          var bestValue = f32(${reduceInitValues[reduceType]});
          let Length = uniforms.reduceSize;
          for (var k = local_idx; k < Length; k = k + ${workgroupSize}) {
           let candidate = f32(${input.getByOffset("offset + k")});
           bestValue = ${reduceOps[reduceType]};
          }
          aBestValues[local_idx] = bestValue;
          workgroupBarrier();

         var reduceSize = min(Length, ${workgroupSize}u);
         for (var currentSize = reduceSize / 2u; reduceSize > 1u;
             currentSize = reduceSize / 2u) {
           let interval = DIV_CEIL(reduceSize, 2u);
           if (local_idx < currentSize) {
            let candidate = aBestValues[local_idx + interval];
            bestValue = ${reduceSharedOps[reduceType]};
            aBestValues[local_idx] = bestValue;
           }
           reduceSize = interval;
           workgroupBarrier();
         }

         if (local_idx == 0u) {
          ${output.setByOffset(
          "outputIndex",
          `${reduceType === "mean" ? `${output.type.storage}(bestValue / f32(uniforms.reduceSize))` : `${output.type.storage}(${reduceOutputValues[reduceType]})`}`
        )};
         }
        }`;
        return {
          name,
          // Note that in JSEP, WG size is not included in cache by default, but WebGPU EP it is.
          shaderCache: { hint: `${cacheKey};${workgroupSize}`, inputDependencies: ["type"] },
          getShaderSource,
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: outputDataType }],
            dispatchGroup: { x: outputSize },
            programUniforms: [{ type: 12 /* uint32 */, data: reduceSize }]
          })
        };
      };
      reduceCommon = (context, name, attributes, reduceType) => {
        const updatedAttributes = context.inputs.length === 1 ? attributes : createReduceAttributesFromInputs(context.inputs, attributes);
        let updatedAxes = updatedAttributes.axes;
        if (updatedAxes.length === 0 && !updatedAttributes.noopWithEmptyAxes) {
          updatedAxes = context.inputs[0].dims.map((_dim, i) => i);
        }
        const normalizeAxes = ShapeUtil.normalizeAxes(updatedAxes, context.inputs[0].dims.length);
        let axes = normalizeAxes;
        let input = context.inputs[0];
        const permutedAxes = getAxesPermutation(axes, context.inputs[0].dims.length);
        if (permutedAxes.length > 0) {
          input = context.compute(createTransposeProgramInfo(context.inputs[0], permutedAxes), {
            inputs: [0],
            outputs: [-1]
          })[0];
          axes = getInnerMostAxes(axes.length, input.dims.length);
        }
        const [outputShape, reduceShape] = computeOutAndReduceShapes(input.dims, axes);
        let finalOutputShape = outputShape;
        if (updatedAttributes.keepDims) {
          finalOutputShape = expandShapeToKeepDim(outputShape, normalizeAxes);
        }
        context.compute(
          createReduceSharedProgramInfo(
            name,
            updatedAttributes.cacheKey,
            [input],
            reduceType,
            context.inputs[0].dataType,
            finalOutputShape,
            reduceShape
          ),
          { inputs: [input] }
        );
      };
      reduceMeanShared = (context, attributes) => {
        reduceCommon(context, "ReduceMeanShared", attributes, "mean");
      };
      reduceL1Shared = (context, attributes) => {
        reduceCommon(context, "ReduceL1Shared", attributes, "l1");
      };
      reduceL2Shared = (context, attributes) => {
        reduceCommon(context, "ReduceL2Shared", attributes, "l2");
      };
      reduceLogSumExpShared = (context, attributes) => {
        reduceCommon(context, "ReduceLogSumExpShared", attributes, "logSumExp");
      };
      reduceMaxShared = (context, attributes) => {
        reduceCommon(context, "ReduceMaxShared", attributes, "max");
      };
      reduceMinShared = (context, attributes) => {
        reduceCommon(context, "ReduceMinShared", attributes, "min");
      };
      reduceProdShared = (context, attributes) => {
        reduceCommon(context, "ReduceProdShared", attributes, "prod");
      };
      reduceSumShared = (context, attributes) => {
        reduceCommon(context, "ReduceSumShared", attributes, "sum");
      };
      reduceSumSquareShared = (context, attributes) => {
        reduceCommon(context, "ReduceSumSquareShared", attributes, "sumSquare");
      };
      reduceLogSumShared = (context, attributes) => {
        reduceCommon(context, "ReduceLogSumShared", attributes, "logSum");
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/reduce.ts
  var validateInputs2, noOp, createReduceProgramInfo, createReduceAttributesFromInputs, runReduceProgram, reduceLogSumNaive, reduceL1Naive, reduceL2Naive, reduceLogSumExpNaive, reduceMaxNaive, reduceMeanNaive, reduceMinNaive, reduceProdNaive, reduceSumNaive, reduceSumSquareNaive, useNaiveReduceMethod, reduceMean, reduceL1, reduceL2, reduceLogSumExp, reduceMax, reduceMin, reduceProd, reduceSum, reduceSumSquare, reduceLogSum;
  var init_reduce = __esm({
    "web/lib/wasm/jsep/webgpu/ops/reduce.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      init_reduce_shared();
      validateInputs2 = (inputs) => {
        if (!inputs || inputs.length === 0 || inputs.length > 2) {
          throw new Error("Reduce op requires 1 or 2 inputs.");
        }
        if (inputs.length === 2 && inputs[1].dims.length !== 1) {
          throw new Error("Invalid axes input dims.");
        }
      };
      noOp = (input) => ["", "", `var value = ${input.getByIndices("input_indices")};`, ""];
      createReduceProgramInfo = (name, shaderCache, inputs, reduceOp, axesInput, outputDataType, keepDims = false, noopWithEmptyAxes = false) => {
        const outputShape = [];
        const inputShape = inputs[0].dims;
        const inputRank = inputShape.length;
        const axes = ShapeUtil.normalizeAxes(axesInput, inputRank);
        const reduceOnAllAxes = !noopWithEmptyAxes && axes.length === 0;
        inputShape.forEach((d, i) => {
          if (reduceOnAllAxes || axes.indexOf(i) >= 0) {
            if (keepDims) {
              outputShape.push(1);
            }
          } else {
            outputShape.push(d);
          }
        });
        const outputRank = outputShape.length;
        const outputSize = ShapeUtil.size(outputShape);
        const getShaderSource = (shaderHelper) => {
          const idxCopy = [];
          const input = inputVariable("_A", inputs[0].dataType, inputRank);
          const output = outputVariable("output", outputDataType, outputRank);
          const ops = reduceOp(input, output, axes);
          let reduceOps2 = ops[2];
          for (let k = 0, l = 0; k < inputRank; k++) {
            if (reduceOnAllAxes || axes.indexOf(k) >= 0) {
              if (keepDims) {
                l++;
              }
              reduceOps2 = `for(var j${k}: u32 = 0; j${k} < ${inputShape[k]}; j${k}++) {
                  ${ops[2].includes("last_index") ? `let last_index = j${k};` : ""}
                  ${input.indicesSet("input_indices", k, `j${k}`)}
                  ${reduceOps2}
                }`;
            } else {
              idxCopy.push(`${input.indicesSet("input_indices", k, output.indicesGet("output_indices", l))};`);
              l++;
            }
          }
          return `

        ${shaderHelper.registerUniform("output_size", "u32").declareVariables(input, output)}

        ${shaderHelper.mainStart()}
          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
          var input_indices: ${input.type.indices};
          let output_indices = ${output.offsetToIndices("global_idx")};

          ${idxCopy.join("\n")}
          ${ops[0]}       // init ops for reduce max/min
          ${ops[1]}
          ${reduceOps2}
          ${ops[3]}
          ${ops.length === 4 ? output.setByOffset("global_idx", "value") : ops.slice(4).join("\n")}
        }`;
        };
        return {
          name,
          shaderCache,
          getShaderSource,
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: outputDataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms: [
              { type: 12 /* uint32 */, data: outputSize },
              ...createTensorShapeVariables(inputShape, outputShape)
            ]
          })
        };
      };
      createReduceAttributesFromInputs = (inputs, attributes) => {
        const axes = [];
        if (inputs[1].dims[0] > 0) {
          inputs[1].getBigInt64Array().forEach((v) => axes.push(Number(v)));
        }
        return createAttributeWithCacheKey({
          axes,
          keepDims: attributes.keepDims,
          noopWithEmptyAxes: attributes.noopWithEmptyAxes
        });
      };
      runReduceProgram = (context, name, attributes, reduceOp) => {
        const inputs = context.inputs;
        const updatedAttributes = inputs.length === 1 ? attributes : createReduceAttributesFromInputs(inputs, attributes);
        context.compute(
          createReduceProgramInfo(
            name,
            { hint: updatedAttributes.cacheKey, inputDependencies: ["rank"] },
            [inputs[0]],
            updatedAttributes.noopWithEmptyAxes && updatedAttributes.axes.length === 0 ? noOp : reduceOp,
            updatedAttributes.axes,
            inputs[0].dataType,
            updatedAttributes.keepDims,
            updatedAttributes.noopWithEmptyAxes
          ),
          { inputs: [0] }
        );
      };
      reduceLogSumNaive = (context, attributes) => {
        validateInputs2(context.inputs);
        const reduceOp = (input, output) => [
          `var value = ${output.type.storage}(0);`,
          "",
          `value += ${input.getByIndices("input_indices")};`,
          "value = log(value);"
        ];
        runReduceProgram(context, "ReduceLogSum", attributes, reduceOp);
      };
      reduceL1Naive = (context, attributes) => {
        validateInputs2(context.inputs);
        const reduceOp = (input, output) => [
          `var value = ${output.type.storage}(0);`,
          "",
          `value += abs(${input.getByIndices("input_indices")});`,
          ""
        ];
        runReduceProgram(context, "ReduceL1", attributes, reduceOp);
      };
      reduceL2Naive = (context, attributes) => {
        validateInputs2(context.inputs);
        const reduceOp = (input, output) => [
          `var t = ${output.type.value}(0); var value = ${output.type.value}(0);`,
          "",
          `t = ${input.getByIndices("input_indices")}; value += (t * t);`,
          "value = sqrt(value);"
        ];
        runReduceProgram(context, "ReduceL2", attributes, reduceOp);
      };
      reduceLogSumExpNaive = (context, attributes) => {
        validateInputs2(context.inputs);
        const reduceOp = (input, output) => [
          `var value = ${output.type.storage}(0);`,
          "",
          `value += exp(${input.getByIndices("input_indices")});`,
          "value = log(value);"
        ];
        runReduceProgram(context, "ReduceLogSumExp", attributes, reduceOp);
      };
      reduceMaxNaive = (context, attributes) => {
        validateInputs2(context.inputs);
        const reduceOp = (input, _output, axes) => {
          const idxZero = [];
          for (let k = 0; k < input.rank; k++) {
            if (axes.indexOf(k) >= 0 || axes.length === 0) {
              idxZero.push(input.indicesSet("input_indices", k, 0));
            }
          }
          return [
            `${idxZero.join("\n")}`,
            `var value = ${input.getByIndices("input_indices")};`,
            `value = max(value, ${input.getByIndices("input_indices")});`,
            ""
          ];
        };
        runReduceProgram(context, "ReduceMax", attributes, reduceOp);
      };
      reduceMeanNaive = (context, attributes) => {
        validateInputs2(context.inputs);
        const reduceOp = (input, output, axes) => {
          let size = 1;
          for (let k = 0; k < input.rank; k++) {
            if (axes.indexOf(k) >= 0 || axes.length === 0) {
              size *= context.inputs[0].dims[k];
            }
          }
          return [
            "var sum = f32(0);",
            "",
            `sum += f32(${input.getByIndices("input_indices")});`,
            `let value = ${output.type.value}(sum / ${size});`
          ];
        };
        runReduceProgram(context, "ReduceMean", attributes, reduceOp);
      };
      reduceMinNaive = (context, attributes) => {
        validateInputs2(context.inputs);
        const reduceOp = (input, _output, axes) => {
          const idxZero = [];
          for (let k = 0; k < input.rank; k++) {
            if (axes.indexOf(k) >= 0 || axes.length === 0) {
              idxZero.push(`input_indices[${k}] = 0;`);
            }
          }
          return [
            `${idxZero.join("\n")}`,
            `var value = ${input.getByIndices("input_indices")};`,
            `value = min(value, ${input.getByIndices("input_indices")});`,
            ""
          ];
        };
        runReduceProgram(context, "ReduceMin", attributes, reduceOp);
      };
      reduceProdNaive = (context, attributes) => {
        validateInputs2(context.inputs);
        const reduceOp = (input, output) => [
          `var value = ${output.type.storage}(1);`,
          "",
          `value *= ${input.getByIndices("input_indices")};`,
          ""
        ];
        runReduceProgram(context, "ReduceProd", attributes, reduceOp);
      };
      reduceSumNaive = (context, attributes) => {
        validateInputs2(context.inputs);
        const reduceOp = (input, output) => [
          `var value = ${output.type.storage}(0);`,
          "",
          `value += ${input.getByIndices("input_indices")};`,
          ""
        ];
        runReduceProgram(context, "ReduceSum", attributes, reduceOp);
      };
      reduceSumSquareNaive = (context, attributes) => {
        validateInputs2(context.inputs);
        const reduceOp = (input, output) => [
          `var t = ${output.type.value}(0); var value = ${output.type.value}(0);`,
          "",
          `t = ${input.getByIndices("input_indices")}; value += t * t;`,
          ""
        ];
        runReduceProgram(context, "ReduceSumSquare", attributes, reduceOp);
      };
      useNaiveReduceMethod = (shape, axes, noopWithEmptyAxes) => {
        if (axes.length === 0) {
          return noopWithEmptyAxes;
        }
        let outputSize = 1;
        let reduceSize = 1;
        for (let dim = 0; dim < axes.length; dim++) {
          if (axes.indexOf(dim) === -1) {
            outputSize *= shape[dim];
          } else {
            reduceSize *= shape[dim];
          }
        }
        return reduceSize < 32 && outputSize > 1024;
      };
      reduceMean = (context, attributes) => {
        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {
          reduceMeanNaive(context, attributes);
        } else {
          reduceMeanShared(context, attributes);
        }
      };
      reduceL1 = (context, attributes) => {
        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {
          reduceL1Naive(context, attributes);
        } else {
          reduceL1Shared(context, attributes);
        }
      };
      reduceL2 = (context, attributes) => {
        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {
          reduceL2Naive(context, attributes);
        } else {
          reduceL2Shared(context, attributes);
        }
      };
      reduceLogSumExp = (context, attributes) => {
        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {
          reduceLogSumExpNaive(context, attributes);
        } else {
          reduceLogSumExpShared(context, attributes);
        }
      };
      reduceMax = (context, attributes) => {
        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {
          reduceMaxNaive(context, attributes);
        } else {
          reduceMaxShared(context, attributes);
        }
      };
      reduceMin = (context, attributes) => {
        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {
          reduceMinNaive(context, attributes);
        } else {
          reduceMinShared(context, attributes);
        }
      };
      reduceProd = (context, attributes) => {
        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {
          reduceProdNaive(context, attributes);
        } else {
          reduceProdShared(context, attributes);
        }
      };
      reduceSum = (context, attributes) => {
        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {
          reduceSumNaive(context, attributes);
        } else {
          reduceSumShared(context, attributes);
        }
      };
      reduceSumSquare = (context, attributes) => {
        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {
          reduceSumSquareNaive(context, attributes);
        } else {
          reduceSumSquareShared(context, attributes);
        }
      };
      reduceLogSum = (context, attributes) => {
        if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {
          reduceLogSumNaive(context, attributes);
        } else {
          reduceLogSumShared(context, attributes);
        }
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/argminmax.ts
  var validateInputs3, argMin, argMax, parseArgMinMaxAttributes;
  var init_argminmax = __esm({
    "web/lib/wasm/jsep/webgpu/ops/argminmax.ts"() {
      "use strict";
      init_wasm_common();
      init_attribute_with_cache_key();
      init_reduce();
      validateInputs3 = (inputs) => {
        if (!inputs || inputs.length === 0 || inputs.length > 2) {
          throw new Error("ArgMinMaxOp op requires 1 or 2 inputs.");
        }
        if (inputs[0].dataType !== 1 /* float */) {
          throw new Error("Invalid input type.");
        }
      };
      argMin = (context, attributes) => {
        validateInputs3(context.inputs);
        const argMinMaxOp = (input, output, axes) => {
          const idxZero = [];
          for (let k = 0; k < input.rank; k++) {
            if (axes.indexOf(k) >= 0 || axes.length === 0) {
              idxZero.push(`input_indices[${k}] = 0;`);
            }
          }
          return [
            `${idxZero.join("\n")}`,
            `var value = ${input.getByIndices("input_indices")};
var best_index : i32 = 0;`,
            `if (${input.getByIndices("input_indices")} ${attributes.selectLastIndex > 0 ? "<=" : "<"} value) {
         value = ${input.getByIndices("input_indices")};
         best_index = i32(last_index);
       }`,
            "",
            output.setByOffset("global_idx", "best_index")
          ];
        };
        context.compute(
          createReduceProgramInfo(
            "ArgMin",
            { hint: attributes.cacheKey, inputDependencies: ["rank"] },
            [context.inputs[0]],
            argMinMaxOp,
            [attributes.axis],
            7 /* int64 */,
            attributes.keepDims
          ),
          { inputs: [0] }
        );
      };
      argMax = (context, attributes) => {
        validateInputs3(context.inputs);
        const argMinMaxOp = (input, output, axes) => {
          const idxZero = [];
          for (let k = 0; k < input.rank; k++) {
            if (axes.indexOf(k) >= 0 || axes.length === 0) {
              idxZero.push(`input_indices[${k}] = 0;`);
            }
          }
          return [
            `${idxZero.join("\n")}`,
            `var value = ${input.getByIndices("input_indices")};
var best_index : i32 = 0;`,
            `if (${input.getByIndices("input_indices")} ${attributes.selectLastIndex > 0 ? ">=" : ">"} value) {
         value = ${input.getByIndices("input_indices")};
         best_index = i32(last_index);
       }`,
            "",
            output.setByOffset("global_idx", "best_index")
          ];
        };
        context.compute(
          createReduceProgramInfo(
            "argMax",
            { hint: attributes.cacheKey, inputDependencies: ["rank"] },
            [context.inputs[0]],
            argMinMaxOp,
            [attributes.axis],
            7 /* int64 */,
            attributes.keepDims
          ),
          { inputs: [0] }
        );
      };
      parseArgMinMaxAttributes = (attributes) => createAttributeWithCacheKey(attributes);
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/attention.ts
  var validateAttentionInputs, initVarStub, createInPlaceSoftmaxProgramInfo, createAttentionProbsProgramInfo, createVxAttentionScoreProgramInfo, applyAttention, prepare, attention;
  var init_attention = __esm({
    "web/lib/wasm/jsep/webgpu/ops/attention.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_types();
      init_common();
      validateAttentionInputs = (inputs, attributes) => {
        const input = inputs[0];
        const weights = inputs[1];
        const bias = inputs[2];
        const maskIndex = inputs[3];
        const past = inputs[4];
        const attentionBias = inputs[5];
        if (past && attentionBias) {
          throw new Error("Attention cannot have both past and attention_bias");
        }
        if (input.dims.length !== 3) {
          throw new Error('Input "input" must have 3 dimensions');
        }
        const batchSize = input.dims[0];
        const sequenceLength = input.dims[1];
        const inputHiddenSize = input.dims[2];
        if (bias.dims.length !== 1) {
          throw new Error('Input "bias" is expected to have 1 dimensions');
        }
        if (weights.dims.length !== 2) {
          throw new Error('Input "weights" is expected to have 2 dimensions');
        }
        if (weights.dims[0] !== inputHiddenSize) {
          throw new Error("Input 1 dimension 0 should have same length as dimension 2 of input 0");
        }
        if (bias.dims[0] !== weights.dims[1]) {
          throw new Error('Input "bias" dimension 0 should have same length as dimension 1 of input "weights"');
        }
        let qHiddenSize = bias.dims[0] / 3;
        let kHiddenSize = qHiddenSize;
        let vHiddenSize = kHiddenSize;
        if (attributes.qkvHiddenSizes.length > 0) {
          if (attributes.qkvHiddenSizes.length !== 3) {
            throw new Error("qkv_hidden_sizes attribute should have 3 elements");
          }
          for (const sz of attributes.qkvHiddenSizes) {
            if (sz % attributes.numHeads !== 0) {
              throw new Error("qkv_hidden_sizes should be divisible by num_heads");
            }
          }
          qHiddenSize = attributes.qkvHiddenSizes[0];
          kHiddenSize = attributes.qkvHiddenSizes[1];
          vHiddenSize = attributes.qkvHiddenSizes[2];
        }
        const kvSequenceLength = sequenceLength;
        if (qHiddenSize !== kHiddenSize) {
          throw new Error("qkv_hidden_sizes first element should be same as the second");
        }
        if (bias.dims[0] !== qHiddenSize + kHiddenSize + vHiddenSize) {
          throw new Error('Input "bias" dimension 0 should have same length as sum of Q/K/V hidden sizes');
        }
        let pastSequenceLength = 0;
        if (past) {
          if (kHiddenSize !== vHiddenSize) {
            throw new Error('Input "past" expect k_hidden_size == v_hidden_size');
          }
          if (past.dims.length !== 5) {
            throw new Error('Input "past" must have 5 dimensions');
          }
          if (past.dims[0] !== 2) {
            throw new Error('Input "past" first dimension must be 2');
          }
          if (past.dims[1] !== batchSize) {
            throw new Error('Input "past" second dimension must be batch_size');
          }
          if (past.dims[2] !== attributes.numHeads) {
            throw new Error('Input "past" third dimension must be num_heads');
          }
          if (past.dims[4] !== kHiddenSize / attributes.numHeads) {
            throw new Error('Input "past" fifth dimension must be k_hidden_size / num_heads');
          }
          if (!attributes.pastPresentShareBuffer) {
            pastSequenceLength = past.dims[3];
          }
        }
        const totalSequenceLength = kvSequenceLength + pastSequenceLength;
        const maxSequenceLength = -1;
        const maskType = 0 /* none */;
        if (maskIndex) {
          throw new Error("Mask not supported");
        }
        if (past) {
          throw new Error("past is not supported");
        }
        if (attentionBias) {
          if (attentionBias.dims.length !== 4) {
            throw new Error('Input "attention_bias" must have 4 dimensions');
          }
          if (attentionBias.dims[0] !== batchSize || attentionBias.dims[1] !== attributes.numHeads || attentionBias.dims[2] !== sequenceLength || attentionBias.dims[3] !== totalSequenceLength) {
            throw new Error('Expect "attention_bias" shape (batch_size, num_heads, sequence_length, total_sequence_length)');
          }
        }
        return {
          batchSize,
          sequenceLength,
          pastSequenceLength,
          kvSequenceLength,
          totalSequenceLength,
          maxSequenceLength,
          inputHiddenSize,
          hiddenSize: qHiddenSize,
          vHiddenSize,
          headSize: Math.floor(qHiddenSize / attributes.numHeads),
          vHeadSize: Math.floor(vHiddenSize / attributes.numHeads),
          numHeads: attributes.numHeads,
          isUnidirectional: false,
          pastPresentShareBuffer: false,
          maskFilterValue: attributes.maskFilterValue,
          maskType,
          scale: attributes.scale,
          broadcastResPosBias: false,
          passPastInKv: false,
          qkvFormat: 1 /* qkvBNSH */
        };
      };
      initVarStub = (seqLensInput, totalSequenceLengthInput, initPastSequenceLength) => {
        if (totalSequenceLengthInput && seqLensInput) {
          return `
      let total_sequence_length_input = u32(${totalSequenceLengthInput.getByOffset("0")});
      let present_sequence_length = max(total_sequence_length_input, uniforms.past_sequence_length);
      let is_subsequent_prompt: bool = sequence_length > 1 && sequence_length != total_sequence_length_input;
      let is_first_prompt: bool = is_subsequent_prompt == false && sequence_length == total_sequence_length_input;
      total_sequence_length = u32(${seqLensInput?.getByOffset("batchIdx")}) + 1;
      var past_sequence_length: u32 = 0;
      if (is_first_prompt == false) {
        past_sequence_length = total_sequence_length - sequence_length;
      }
       `;
        } else {
          return `
    ${initPastSequenceLength ? "let past_sequence_length = uniforms.past_sequence_length" : ""};
    let present_sequence_length = total_sequence_length;
    `;
        }
      };
      createInPlaceSoftmaxProgramInfo = (input, batchSize, numHeads, pastSequenceLength, sequenceLength, totalSequenceLength, seqLens, totalSequenceLengthInput) => {
        const components = getMaxComponents(seqLens ? 1 : totalSequenceLength);
        let WG = 64;
        const totalSequenceLengthComp = totalSequenceLength / components;
        if (totalSequenceLengthComp < WG) {
          WG = 32;
        }
        const elementsPerThread = Math.ceil(totalSequenceLength / components / WG);
        const programUniforms = [
          { type: 12 /* uint32 */, data: batchSize },
          { type: 12 /* uint32 */, data: numHeads },
          { type: 12 /* uint32 */, data: pastSequenceLength },
          { type: 12 /* uint32 */, data: sequenceLength },
          { type: 12 /* uint32 */, data: totalSequenceLengthComp },
          { type: 12 /* uint32 */, data: elementsPerThread }
        ];
        const dataType = tensorTypeToWsglStorageType(input.dataType, components);
        const f32Type = tensorTypeToWsglValueType(1 /* float */, components);
        const inputDependencies = ["type"];
        if (seqLens) {
          inputDependencies.push("type");
        }
        if (totalSequenceLengthInput) {
          inputDependencies.push("type");
        }
        const getShaderSource = (shaderHelper) => {
          const inputHelper = outputVariable("x", input.dataType, input.dims, components);
          const inputHelpers = [inputHelper];
          const seqLensInputHelper = seqLens ? inputVariable("seq_lens", seqLens.dataType, seqLens.dims) : void 0;
          if (seqLensInputHelper) {
            inputHelpers.push(seqLensInputHelper);
          }
          const totalSequenceLengthInputHelper = totalSequenceLengthInput ? inputVariable("total_sequence_length_input", totalSequenceLengthInput.dataType, totalSequenceLengthInput.dims) : void 0;
          if (totalSequenceLengthInputHelper) {
            inputHelpers.push(totalSequenceLengthInputHelper);
          }
          const elemValueType = tensorTypeToWsglValueType(input.dataType);
          const uniforms = [
            { name: "batch_size", type: "u32" },
            { name: "num_heads", type: "u32" },
            { name: "past_sequence_length", type: "u32" },
            { name: "sequence_length", type: "u32" },
            { name: "total_sequence_length", type: "u32" },
            { name: "elements_per_thread", type: "u32" }
          ];
          return `
  var<workgroup> thread_max: array<f32, ${WG}>;
  var<workgroup> thread_sum: array<f32, ${WG}>;
  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputHelpers)}
  ${shaderHelper.mainStart([WG, 1, 1])}
    let batchIdx = workgroup_id.z / uniforms.num_heads;
    let headIdx = workgroup_id.z % uniforms.num_heads;
    let sequence_length = uniforms.sequence_length;
    var total_sequence_length = uniforms.total_sequence_length;
    ${initVarStub(seqLensInputHelper, totalSequenceLengthInputHelper, false)}
    let local_offset = local_idx * uniforms.elements_per_thread;
    let offset = (global_idx / ${WG}) * uniforms.total_sequence_length + local_offset;
    let seq_causal_length = ${seqLens ? "u32(past_sequence_length + workgroup_id.y + 1)" : "total_sequence_length"};
    var thread_max_vector = ${f32Type}(-3.4028234663852886e+38f);
    for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < seq_causal_length; i++) {
      thread_max_vector = max(${f32Type}(x[offset + i]), thread_max_vector);
    }
    thread_max[local_idx] = ${(() => {
            switch (components) {
              case 1:
                return "thread_max_vector";
              case 2:
                return "max(thread_max_vector.x, thread_max_vector.y)";
              case 4:
                return "max(max(thread_max_vector.x, thread_max_vector.y), max(thread_max_vector.z, thread_max_vector.w))";
              default:
                throw new Error(`Unsupported components: ${components}`);
            }
          })()};
    workgroupBarrier();

    var max_value =  f32(-3.4028234663852886e+38f);
    for (var i = 0u; i < ${WG}; i++) {
      max_value = max(thread_max[i], max_value);
    }

    var sum_vector = ${f32Type}(0);
    for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < seq_causal_length; i++) {
      sum_vector += exp(${f32Type}(x[offset + i]) - max_value);
    }
    thread_sum[local_idx] = ${(() => {
            switch (components) {
              case 1:
                return "sum_vector";
              case 2:
                return "sum_vector.x + sum_vector.y";
              case 4:
                return "sum_vector.x + sum_vector.y + sum_vector.z + sum_vector.w";
              default:
                throw new Error(`Unsupported components: ${components}`);
            }
          })()};
    workgroupBarrier();

    var sum: f32 = 0;
    for (var i = 0u; i < ${WG}; i++) {
      sum += thread_sum[i];
    }

    if (sum == 0) {
      for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < seq_causal_length; i++) {
        x[offset + i] = ${inputHelper.type.value}(${elemValueType}(1.0) / ${elemValueType}(seq_causal_length));
      }
    } else {
      for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < seq_causal_length; i++) {
        var f32input = ${f32Type}(x[offset + i]);
        x[offset + i] = ${inputHelper.type.value}(exp(f32input - max_value) / sum);
      }
    }
      ${seqLens ? `
        for (var total_seq_id: u32 = seq_causal_length; total_seq_id + local_offset < uniforms.total_sequence_length; total_seq_id++) {
          x[offset + total_seq_id] = ${inputHelper.type.value}(${elemValueType}(0));
        }` : ""};
  }`;
        };
        return {
          name: "AttentionProbsSoftmax",
          shaderCache: { hint: `${WG};${dataType};${components}`, inputDependencies },
          getShaderSource,
          getRunData: () => ({
            outputs: [],
            dispatchGroup: { x: 1, y: sequenceLength, z: batchSize * numHeads },
            programUniforms
          })
        };
      };
      createAttentionProbsProgramInfo = (outputCount, q, key, pastKey, attentionBias, parameters, pastSequenceLength, seqLens, totalSequenceLengthInput) => {
        const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength;
        const probsShape = [parameters.batchSize, parameters.numHeads, parameters.sequenceLength, totalSequenceLength];
        const presentKey = outputCount > 1 && pastKey;
        const kvNumHeads = parameters.kvNumHeads ? parameters.kvNumHeads : parameters.numHeads;
        const presentKeyShape = presentKey ? [parameters.batchSize, kvNumHeads, totalSequenceLength, parameters.headSize] : void 0;
        const nReps = parameters.nReps ? parameters.nReps : 1;
        const alpha = parameters.scale === 0 ? 1 / Math.sqrt(parameters.headSize) : parameters.scale;
        const components = getMaxComponents(parameters.headSize);
        const vectorizedHeadSize = parameters.headSize / components;
        const TILE_SIZE = 12;
        const dispatch = {
          x: Math.ceil(totalSequenceLength / TILE_SIZE),
          y: Math.ceil(parameters.sequenceLength / TILE_SIZE),
          z: parameters.batchSize * parameters.numHeads
        };
        const programUniforms = [
          { type: 12 /* uint32 */, data: parameters.sequenceLength },
          { type: 12 /* uint32 */, data: vectorizedHeadSize },
          { type: 12 /* uint32 */, data: totalSequenceLength },
          { type: 12 /* uint32 */, data: parameters.numHeads },
          { type: 12 /* uint32 */, data: parameters.headSize },
          { type: 1 /* float */, data: alpha },
          { type: 12 /* uint32 */, data: pastSequenceLength },
          { type: 12 /* uint32 */, data: parameters.kvSequenceLength },
          { type: 12 /* uint32 */, data: nReps }
        ];
        const feedPastKey = presentKey && pastKey && ShapeUtil.size(pastKey.dims) > 0;
        const inputDependencies = ["type", "type"];
        if (feedPastKey) {
          inputDependencies.push("type");
        }
        if (attentionBias) {
          inputDependencies.push("type");
        }
        if (seqLens) {
          inputDependencies.push("type");
        }
        if (totalSequenceLengthInput) {
          inputDependencies.push("type");
        }
        const outputs = [{ dims: probsShape, dataType: q.dataType, gpuDataType: 0 /* default */ }];
        if (presentKey) {
          outputs.push({ dims: presentKeyShape, dataType: q.dataType, gpuDataType: 0 /* default */ });
        }
        const getShaderSource = (shaderHelper) => {
          const qInput = inputVariable("q", q.dataType, q.dims, components);
          const kInput = inputVariable("key", key.dataType, key.dims, components);
          const inputVars = [qInput, kInput];
          if (feedPastKey) {
            const pastKeyInput = inputVariable("past_key", pastKey.dataType, pastKey.dims, components);
            inputVars.push(pastKeyInput);
          }
          if (attentionBias) {
            inputVars.push(inputVariable("attention_bias", attentionBias.dataType, attentionBias.dims));
          }
          const seqLensInputVariable = seqLens ? inputVariable("seq_lens", seqLens.dataType, seqLens.dims) : void 0;
          if (seqLensInputVariable) {
            inputVars.push(seqLensInputVariable);
          }
          const totalSequenceLengthInputVariable = totalSequenceLengthInput ? inputVariable("total_sequence_length_input", totalSequenceLengthInput.dataType, totalSequenceLengthInput.dims) : void 0;
          if (totalSequenceLengthInputVariable) {
            inputVars.push(totalSequenceLengthInputVariable);
          }
          const output = outputVariable("output", q.dataType, probsShape);
          const outputVars = [output];
          if (presentKey) {
            outputVars.push(outputVariable("present_key", q.dataType, presentKeyShape, components));
          }
          const f32Type = tensorTypeToWsglValueType(1 /* float */, components);
          const uniforms = [
            { name: "M", type: "u32" },
            { name: "K", type: "u32" },
            { name: "N", type: "u32" },
            { name: "num_heads", type: "u32" },
            { name: "head_size", type: "u32" },
            { name: "alpha", type: "f32" },
            { name: "past_sequence_length", type: "u32" },
            { name: "kv_sequence_length", type: "u32" },
            { name: "n_reps", type: "u32" }
          ];
          return `
  const TILE_SIZE = ${TILE_SIZE}u;

  var<workgroup> tileQ: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>;
  var<workgroup> tileK: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>;
  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, ...outputVars)}
  ${shaderHelper.mainStart([TILE_SIZE, TILE_SIZE, 1])}
    // x holds the N and y holds the M
    let headIdx = workgroup_id.z % uniforms.num_heads;
    let kvHeadIdx = ${nReps === 1 ? "headIdx" : "headIdx / uniforms.n_reps"};
    let kv_num_heads = ${nReps === 1 ? "uniforms.num_heads" : "uniforms.num_heads / uniforms.n_reps"};
    let batchIdx = workgroup_id.z / uniforms.num_heads;
    let m = workgroup_id.y * TILE_SIZE;
    let n = workgroup_id.x * TILE_SIZE;
    let sequence_length = uniforms.M;
    var total_sequence_length = uniforms.N;
    ${initVarStub(seqLensInputVariable, totalSequenceLengthInputVariable, true)}
    let absKvHeadIdx = batchIdx * kv_num_heads + kvHeadIdx;
    let qOffset = workgroup_id.z * uniforms.M * uniforms.K + m * uniforms.K;
    ${feedPastKey && presentKey ? "let pastKeyOffset = absKvHeadIdx * uniforms.past_sequence_length * uniforms.K;" : ""};
    let kOffset = absKvHeadIdx * uniforms.kv_sequence_length * uniforms.K;
    ${presentKey ? "let presentKeyOffset = absKvHeadIdx * uniforms.N * uniforms.K;" : ""}
    var value = ${f32Type}(0);
    for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {
      if (global_id.y < uniforms.M && w + local_id.x < uniforms.K) {
        tileQ[TILE_SIZE * local_id.y + local_id.x] = q[qOffset + local_id.y * uniforms.K + w + local_id.x];
      }
      if (n + local_id.y < uniforms.N && w + local_id.x < uniforms.K) {
        var idx = TILE_SIZE * local_id.y + local_id.x;
      ${(() => {
            if (feedPastKey && presentKey) {
              return `
              if (n + local_id.y < past_sequence_length) {
                tileK[idx] = past_key[pastKeyOffset + (n + local_id.y) * uniforms.K + w + local_id.x];
              } else if (n + local_id.y - past_sequence_length < uniforms.kv_sequence_length) {
                tileK[idx] = key[kOffset + (n + local_id.y - past_sequence_length) * uniforms.K + w + local_id.x];
              }`;
            } else {
              return `
          if (n + local_id.y < uniforms.kv_sequence_length) {
            tileK[idx] = key[kOffset + (n + local_id.y) * uniforms.K + w + local_id.x];
          }`;
            }
          })()}
      ${presentKey ? `if (n + local_id.y < present_sequence_length) {
        present_key[presentKeyOffset + (n + local_id.y) * uniforms.K + w + local_id.x] = tileK[idx];
      }` : ""}
      }
      workgroupBarrier();

      for (var k: u32 = 0u; k < TILE_SIZE && w+k < uniforms.K; k++) {
          value += ${f32Type}(tileQ[TILE_SIZE * local_id.y + k] * tileK[TILE_SIZE * local_id.x + k]);
      }

      workgroupBarrier();
    }

    if (global_id.y < uniforms.M && global_id.x < total_sequence_length) {
      let headOffset = workgroup_id.z * uniforms.M * uniforms.N;
      let outputIdx = headOffset + global_id.y * uniforms.N + global_id.x;
      var sum: f32 = ${(() => {
            switch (components) {
              case 1:
                return "value";
              case 2:
                return "value.x + value.y";
              case 4:
                return "value.x + value.y + value.z + value.w";
              default:
                throw new Error(`Unsupported components: ${components}`);
            }
          })()};
        output[outputIdx] = ${output.type.value} (sum * uniforms.alpha) + ${attentionBias ? "attention_bias[outputIdx]" : "0.0"};
    }
  }`;
        };
        return {
          name: "AttentionProbs",
          shaderCache: {
            hint: `${components};${attentionBias !== void 0};${pastKey !== void 0};${outputCount}`,
            inputDependencies
          },
          getRunData: () => ({ outputs, dispatchGroup: dispatch, programUniforms }),
          getShaderSource
        };
      };
      createVxAttentionScoreProgramInfo = (outputCount, probs, v, pastValue, params, pastSequenceLength, seqLens = void 0, totalSequenceLengthInput = void 0) => {
        const totalSequenceLength = pastSequenceLength + params.kvSequenceLength;
        const nReps = params.nReps ? params.nReps : 1;
        const repeatedVHiddenSize = params.vHiddenSize * nReps;
        const presentValue = outputCount > 1 && pastValue;
        const kvNumHeads = params.kvNumHeads ? params.kvNumHeads : params.numHeads;
        const presentValueShape = presentValue ? [params.batchSize, kvNumHeads, totalSequenceLength, params.headSize] : void 0;
        const outputShape = [params.batchSize, params.sequenceLength, repeatedVHiddenSize];
        const TILE_SIZE = 12;
        const dispatch = {
          x: Math.ceil(params.vHeadSize / TILE_SIZE),
          y: Math.ceil(params.sequenceLength / TILE_SIZE),
          z: params.batchSize * params.numHeads
        };
        const programUniforms = [
          { type: 12 /* uint32 */, data: params.sequenceLength },
          { type: 12 /* uint32 */, data: totalSequenceLength },
          { type: 12 /* uint32 */, data: params.vHeadSize },
          { type: 12 /* uint32 */, data: params.numHeads },
          { type: 12 /* uint32 */, data: params.headSize },
          { type: 12 /* uint32 */, data: repeatedVHiddenSize },
          { type: 12 /* uint32 */, data: pastSequenceLength },
          { type: 12 /* uint32 */, data: params.kvSequenceLength },
          { type: 12 /* uint32 */, data: nReps }
        ];
        const feedPastValue = presentValue && pastValue && ShapeUtil.size(pastValue.dims) > 0;
        const inputDependencies = ["type", "type"];
        if (feedPastValue) {
          inputDependencies.push("type");
        }
        if (seqLens) {
          inputDependencies.push("type");
        }
        if (totalSequenceLengthInput) {
          inputDependencies.push("type");
        }
        const outputs = [{ dims: outputShape, dataType: probs.dataType, gpuDataType: 0 /* default */ }];
        if (presentValue) {
          outputs.push({ dims: presentValueShape, dataType: probs.dataType, gpuDataType: 0 /* default */ });
        }
        const getShaderSource = (shaderHelper) => {
          const probsHelper = inputVariable("probs", probs.dataType, probs.dims);
          const vHelper = inputVariable("v", v.dataType, v.dims);
          const inputVars = [probsHelper, vHelper];
          if (feedPastValue) {
            inputVars.push(inputVariable("past_value", pastValue.dataType, pastValue.dims));
          }
          const seqLensInputVariable = seqLens ? inputVariable("seq_lens", seqLens.dataType, seqLens.dims) : void 0;
          if (seqLens) {
            inputVars.push(seqLensInputVariable);
          }
          const totalSequenceLengthInputVariable = totalSequenceLengthInput ? inputVariable("total_sequence_length_input", totalSequenceLengthInput.dataType, totalSequenceLengthInput.dims) : void 0;
          if (totalSequenceLengthInput) {
            inputVars.push(totalSequenceLengthInputVariable);
          }
          const output = outputVariable("output", probs.dataType, outputShape);
          const outputVars = [output];
          if (presentValue) {
            outputVars.push(outputVariable("present_value", probs.dataType, presentValueShape));
          }
          const uniforms = [
            { name: "M", type: "u32" },
            { name: "K", type: "u32" },
            { name: "N", type: "u32" },
            { name: "num_heads", type: "u32" },
            { name: "head_size", type: "u32" },
            { name: "v_hidden_size", type: "u32" },
            { name: "past_sequence_length", type: "u32" },
            { name: "kv_sequence_length", type: "u32" },
            { name: "n_reps", type: "u32" }
          ];
          return `
  const TILE_SIZE = ${TILE_SIZE}u;
  var<workgroup> tileQ: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>;
  var<workgroup> tileV: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>;
  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, ...outputVars)}
  ${shaderHelper.mainStart([TILE_SIZE, TILE_SIZE, 1])}
   let headIdx = workgroup_id.z % uniforms.num_heads;
   let batchIdx = workgroup_id.z / uniforms.num_heads;
   let kvHeadIdx = ${nReps === 1 ? "headIdx" : "headIdx / uniforms.n_reps"};
   let kv_num_heads = ${nReps === 1 ? "uniforms.num_heads" : "uniforms.num_heads / uniforms.n_reps"};
   let m = global_id.y;
   let n = global_id.x;
   let sequence_length = uniforms.M;
   var total_sequence_length = uniforms.K;
   ${initVarStub(seqLensInputVariable, totalSequenceLengthInputVariable, true)}
   let offsetA = workgroup_id.z * uniforms.M * uniforms.K + m * uniforms.K;
   let absKvHeadIdx = batchIdx * kv_num_heads + kvHeadIdx; // kvHeadIdx is relative to the batch
   ${feedPastValue && presentValue ? "let pastValueOffset = absKvHeadIdx * uniforms.N * uniforms.past_sequence_length + n;" : ""};
   let vOffset = absKvHeadIdx * uniforms.N * uniforms.kv_sequence_length + n;
   ${presentValue ? "let presentValueOffset = absKvHeadIdx * uniforms.N * uniforms.K + n;" : ""}
   var value = ${probsHelper.type.storage}(0);
   for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {
      if (m < uniforms.M && w + local_id.x < uniforms.K) {
        tileQ[TILE_SIZE * local_id.y + local_id.x] = probs[offsetA + w + local_id.x];
      }
      if (n < uniforms.N && w + local_id.y < uniforms.K) {
        var idx = TILE_SIZE * local_id.y + local_id.x;
        ${(() => {
            if (feedPastValue && presentValue) {
              return `
        if (w + local_id.y < past_sequence_length) {
          tileV[idx] = past_value[pastValueOffset + (w + local_id.y) * uniforms.N];
        } else if (w + local_id.y - past_sequence_length < uniforms.kv_sequence_length) {
          tileV[idx] = v[vOffset + (w + local_id.y - past_sequence_length) * uniforms.N];
        }
      `;
            } else {
              return `
            if (w + local_id.y < uniforms.kv_sequence_length) {
              tileV[idx] = v[vOffset + (w + local_id.y) * uniforms.N];
            }`;
            }
          })()}
        ${presentValue ? `
            if (w + local_id.y < present_sequence_length) {
          present_value[presentValueOffset + (w + local_id.y) * uniforms.N] = tileV[idx];
        }` : ""}
      }
     workgroupBarrier();
     for (var k: u32 = 0u; k < TILE_SIZE && w+k < total_sequence_length; k++) {
       value += tileQ[TILE_SIZE * local_id.y + k] * tileV[TILE_SIZE * k + local_id.x];
     }
     workgroupBarrier();
   }

   // we need to transpose output from BNSH_v to BSND_v
   if (m < uniforms.M && n < uniforms.N) {
     let outputIdx = batchIdx * uniforms.M * uniforms.v_hidden_size + m * uniforms.v_hidden_size
       + headIdx * uniforms.N + n;
     output[outputIdx] = value;
   }
  }`;
        };
        return {
          name: "AttentionScore",
          shaderCache: { hint: `${pastValue !== void 0};${outputCount}`, inputDependencies },
          getRunData: () => ({ outputs, dispatchGroup: dispatch, programUniforms }),
          getShaderSource
        };
      };
      applyAttention = (context, q, k, v, _maskIndex, _past, pastKey, pastValue, attentionBiasInput, parameters, seqLens = void 0, totalSequenceLengthInput = void 0) => {
        const outputCount = Math.min(context.outputCount, 1 + (pastKey ? 1 : 0) + (pastValue ? 1 : 0));
        const effectivePastKey = outputCount > 1 ? pastKey : void 0;
        const effectivePastValue = outputCount > 1 ? pastValue : void 0;
        const pastSequenceLength = outputCount > 1 ? parameters.pastSequenceLength : 0;
        const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength;
        const attentionBias = attentionBiasInput && ShapeUtil.size(attentionBiasInput.dims) > 0 ? attentionBiasInput : void 0;
        const inputsK = [q, k];
        if (effectivePastKey && ShapeUtil.size(effectivePastKey.dims) > 0) {
          inputsK.push(effectivePastKey);
        }
        if (attentionBias) {
          inputsK.push(attentionBias);
        }
        if (seqLens) {
          inputsK.push(seqLens);
        }
        if (totalSequenceLengthInput) {
          inputsK.push(totalSequenceLengthInput);
        }
        const probs = context.compute(
          createAttentionProbsProgramInfo(
            outputCount,
            q,
            k,
            effectivePastKey,
            attentionBias,
            parameters,
            pastSequenceLength,
            seqLens,
            totalSequenceLengthInput
          ),
          { inputs: inputsK, outputs: outputCount > 1 ? [-1, 1] : [-1] }
        )[0];
        context.compute(
          createInPlaceSoftmaxProgramInfo(
            probs,
            parameters.batchSize,
            parameters.numHeads,
            pastSequenceLength,
            parameters.sequenceLength,
            totalSequenceLength,
            seqLens,
            totalSequenceLengthInput
          ),
          { inputs: seqLens && totalSequenceLengthInput ? [probs, seqLens, totalSequenceLengthInput] : [probs], outputs: [] }
        );
        const inputsV = [probs, v];
        if (effectivePastValue && ShapeUtil.size(effectivePastValue.dims) > 0) {
          inputsV.push(effectivePastValue);
        }
        if (seqLens) {
          inputsV.push(seqLens);
        }
        if (totalSequenceLengthInput) {
          inputsV.push(totalSequenceLengthInput);
        }
        context.compute(
          createVxAttentionScoreProgramInfo(
            outputCount,
            probs,
            v,
            effectivePastValue,
            parameters,
            pastSequenceLength,
            seqLens,
            totalSequenceLengthInput
          ),
          {
            inputs: inputsV,
            outputs: outputCount > 1 ? [0, 2] : [0]
          }
        );
      };
      prepare = (context, parameters) => {
        const outputShape = [parameters.batchSize, parameters.numHeads, parameters.sequenceLength, parameters.headSize];
        const M = parameters.sequenceLength;
        const K = parameters.inputHiddenSize;
        const N = parameters.headSize;
        const TILE_SIZE = 12;
        const dispatch = {
          x: Math.ceil(parameters.headSize / TILE_SIZE),
          y: Math.ceil(parameters.sequenceLength / TILE_SIZE),
          z: parameters.batchSize * parameters.numHeads
        };
        const inputs = [context.inputs[0], context.inputs[1], context.inputs[2]];
        const programUniforms = [
          { type: 12 /* uint32 */, data: M },
          { type: 12 /* uint32 */, data: K },
          { type: 12 /* uint32 */, data: N },
          { type: 12 /* uint32 */, data: parameters.numHeads },
          { type: 12 /* uint32 */, data: parameters.headSize },
          { type: 12 /* uint32 */, data: parameters.hiddenSize },
          { type: 12 /* uint32 */, data: parameters.hiddenSize + parameters.hiddenSize + parameters.vHiddenSize }
        ];
        const getShaderSource = (shaderHelper) => {
          const outputQ = outputVariable("output_q", inputs[0].dataType, outputShape);
          const outputK = outputVariable("output_k", inputs[0].dataType, outputShape);
          const outputV = outputVariable("output_v", inputs[0].dataType, outputShape);
          const input = inputVariable("input", inputs[0].dataType, inputs[0].dims);
          const weight = inputVariable("weight", inputs[1].dataType, inputs[1].dims);
          const bias = inputVariable("bias", inputs[2].dataType, inputs[2].dims);
          const dataType = input.type.storage;
          const uniforms = [
            { name: "M", type: "u32" },
            { name: "K", type: "u32" },
            { name: "N", type: "u32" },
            { name: "num_heads", type: "u32" },
            { name: "head_size", type: "u32" },
            { name: "hidden_size", type: "u32" },
            { name: "ldb", type: "u32" }
          ];
          return `
  const TILE_SIZE = ${TILE_SIZE}u;
  var<workgroup> tileInput: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;
  var<workgroup> tileWeightQ: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;
  var<workgroup> tileWeightK: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;
  var<workgroup> tileWeightV: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;
  ${shaderHelper.registerUniforms(uniforms).declareVariables(input, weight, bias, outputQ, outputK, outputV)}
  ${shaderHelper.mainStart([TILE_SIZE, TILE_SIZE, 1])}
    let batchIndex = workgroup_id.z / uniforms.num_heads;
    let headNumber = workgroup_id.z % uniforms.num_heads;
    let m = global_id.y;
    let n = global_id.x;

    let inputOffset = batchIndex * (uniforms.M * uniforms.K) + m * uniforms.K;
    let biasOffsetQ = headNumber * uniforms.head_size;
    let biasOffsetK = uniforms.hidden_size + biasOffsetQ;
    let biasOffsetV = uniforms.hidden_size + biasOffsetK;

    var valueQ = ${dataType}(0);
    var valueK = ${dataType}(0);
    var valueV = ${dataType}(0);
    for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {
      if (m < uniforms.M && w + local_id.x < uniforms.K) {
        tileInput[TILE_SIZE * local_id.y + local_id.x] = input[inputOffset + w + local_id.x];
      }
      if (n < uniforms.N && w + local_id.y < uniforms.K) {
        let offset = n + (w + local_id.y) * uniforms.ldb;
        tileWeightQ[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetQ + offset];
        tileWeightK[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetK + offset];
        tileWeightV[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetV + offset];
      }
      workgroupBarrier();
      for (var k: u32 = 0u; k<TILE_SIZE && w+k < uniforms.K; k++) {
        let inputTileOffset = TILE_SIZE * local_id.y + k;
        let weightTileOffset = TILE_SIZE * k + local_id.x;
        valueQ += tileInput[inputTileOffset] * tileWeightQ[weightTileOffset];
        valueK += tileInput[inputTileOffset] * tileWeightK[weightTileOffset];
        valueV += tileInput[inputTileOffset] * tileWeightV[weightTileOffset];
      }

      workgroupBarrier();
    }

    let headOffset = (m * uniforms.N + n) % uniforms.head_size;
    valueQ += bias[headOffset + biasOffsetQ];
    valueK += bias[headOffset + biasOffsetK];
    valueV += bias[headOffset + biasOffsetV];

    let offset = workgroup_id.z * uniforms.M * uniforms.N;
    if (m < uniforms.M && n < uniforms.N) {
      let outputIdx = offset + m * uniforms.N + n;
      output_q[outputIdx] = valueQ;
      output_k[outputIdx] = valueK;
      output_v[outputIdx] = valueV;
    }
  }`;
        };
        return context.compute(
          {
            name: "AttentionPrepare",
            shaderCache: { inputDependencies: ["type", "type", "type"] },
            getRunData: () => ({
              outputs: [
                { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: 0 /* default */ },
                { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: 0 /* default */ },
                { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: 0 /* default */ }
              ],
              dispatchGroup: dispatch,
              programUniforms
            }),
            getShaderSource
          },
          { inputs, outputs: [-1, -1, -1] }
        );
      };
      attention = (context, attributes) => {
        const params = validateAttentionInputs(context.inputs, attributes);
        const [q, k, v] = prepare(context, params);
        return applyAttention(
          context,
          q,
          k,
          v,
          context.inputs[4],
          void 0,
          void 0,
          void 0,
          context.inputs[5],
          params
        );
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/batch-norm.ts
  var validateInputs4, createBatchNormInferenceProgramInfo, parseBatchNormAttributes, batchNorm;
  var init_batch_norm = __esm({
    "web/lib/wasm/jsep/webgpu/ops/batch-norm.ts"() {
      "use strict";
      init_esm();
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      validateInputs4 = (inputs, attributes) => {
        if (!inputs || inputs.length !== 5) {
          throw new Error("BatchNormalization requires 5 inputs");
        }
        const checkShapeEqual = (actual, expected, message) => {
          const r = expected.length;
          if (r !== actual.length) {
            throw new Error(`${message}: num dimensions != ${r}`);
          }
          expected.forEach((v, i) => {
            if (v !== actual[i]) {
              throw new Error(`${message}: dim[${i}] do not match`);
            }
          });
        };
        if (inputs[0].dims.length > 1) {
          const shape = attributes.format === "NHWC" ? attributes.spatial ? inputs[0].dims.slice(-1) : inputs[0].dims.slice(-1).concat(inputs[0].dims.slice(1, inputs[0].dims.length - 1)) : inputs[0].dims.slice(1, attributes.spatial ? 2 : void 0);
          checkShapeEqual(inputs[1].dims, shape, "Invalid input scale");
          checkShapeEqual(inputs[2].dims, shape, "Invalid input B");
          checkShapeEqual(inputs[3].dims, shape, "Invalid input mean");
          checkShapeEqual(inputs[4].dims, shape, "Invalid input var");
        } else {
          checkShapeEqual(inputs[1].dims, [1], "Invalid input scale");
          checkShapeEqual(inputs[2].dims, [1], "Invalid input B");
          checkShapeEqual(inputs[3].dims, [1], "Invalid input mean");
          checkShapeEqual(inputs[4].dims, [1], "Invalid input var");
        }
      };
      createBatchNormInferenceProgramInfo = (inputs, attributes) => {
        const { epsilon, spatial, format } = attributes;
        const yShape = inputs[0].dims;
        const components = spatial ? getMaxComponents(yShape[yShape.length - 1]) : 1;
        const cComponents = format === "NHWC" && yShape.length > 1 ? components : 1;
        const outputSize = ShapeUtil.size(yShape) / components;
        const useShapesUniforms = spatial;
        const shapeOrRank = useShapesUniforms ? yShape.length : yShape;
        const x = inputVariable("x", inputs[0].dataType, inputs[0].dims, components);
        const scale = inputVariable("scale", inputs[1].dataType, inputs[1].dims, cComponents);
        const bias = inputVariable("bias", inputs[2].dataType, inputs[2].dims, cComponents);
        const inputMean = inputVariable("inputMean", inputs[3].dataType, inputs[3].dims, cComponents);
        const inputVar = inputVariable("inputVar", inputs[4].dataType, inputs[4].dims, cComponents);
        const y = outputVariable("y", inputs[0].dataType, shapeOrRank, components);
        const calcCOffset = () => {
          let cOffset = "";
          if (spatial) {
            cOffset = `let cOffset = ${yShape.length === 1 ? "0u" : format === "NHWC" ? `outputIndices[${yShape.length - 1}] / ${components}` : "outputIndices[1]"};`;
          } else {
            if (format === "NCHW") {
              cOffset = `
            ${y.indicesSet("outputIndices", "0", "0")}
            let cOffset = ${y.indicesToOffset("outputIndices")};`;
            } else {
              cOffset = `var cIndices = ${scale.type.indices}(0);
                       cIndices[0] = outputIndices[${yShape.length - 1}];`;
              for (let i = 1; i < scale.rank; i++) {
                cOffset += `cIndices[${i}] = outputIndices[${i}];`;
              }
              cOffset += `let cOffset = ${scale.indicesToOffset("cIndices")};`;
            }
          }
          return cOffset;
        };
        const getInferenceModeShaderSource = (helper) => `
  const epsilon = ${epsilon};
  ${helper.registerUniform("outputSize", "u32").declareVariables(x, scale, bias, inputMean, inputVar, y)}
  ${helper.mainStart()}
  ${helper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}
    var outputIndices = ${y.offsetToIndices(`global_idx * ${components}`)};
    ${calcCOffset()}
    let scale = ${scale.getByOffset("cOffset")};
    let bias = ${bias.getByOffset("cOffset")};
    let inputMean = ${inputMean.getByOffset("cOffset")};
    let inputVar = ${inputVar.getByOffset("cOffset")};
    let x = ${x.getByOffset("global_idx")};
    let value = (x - inputMean) * inverseSqrt(inputVar + epsilon) * scale + bias;
    ${y.setByOffset("global_idx", "value")}
  }`;
        return {
          name: "BatchNormalization",
          shaderCache: {
            hint: `${attributes.epsilon}_${attributes.format}_${spatial}_${components}`,
            inputDependencies: useShapesUniforms ? ["rank", "type", "type", "type", "type"] : void 0
          },
          getShaderSource: getInferenceModeShaderSource,
          getRunData: () => ({
            outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms: useShapesUniforms ? [{ type: 12 /* uint32 */, data: outputSize }, ...createTensorShapeVariables(yShape)] : [{ type: 12 /* uint32 */, data: outputSize }]
          })
        };
      };
      parseBatchNormAttributes = (attributes) => createAttributeWithCacheKey(attributes);
      batchNorm = (context, attributes) => {
        const { inputs, outputCount } = context;
        const updatedAttributes = parseBatchNormAttributes({ ...attributes, outputCount });
        if (env2.webgpu.validateInputContent) {
          validateInputs4(inputs, updatedAttributes);
        }
        if (attributes.trainingMode) {
          throw new Error("BatchNormalization trainingMode is not supported yet.");
        } else {
          context.compute(createBatchNormInferenceProgramInfo(inputs, updatedAttributes));
        }
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/bias-add.ts
  var validateInputs5, createBiasAddProgramInfo, biasAdd;
  var init_bias_add = __esm({
    "web/lib/wasm/jsep/webgpu/ops/bias-add.ts"() {
      "use strict";
      init_util();
      init_common();
      validateInputs5 = (inputs) => {
        if (inputs[0].dims.length !== 3) {
          throw new Error("input should have 3 dimensions");
        }
        if (![320, 640, 1280].includes(inputs[0].dims[2])) {
          throw new Error("number of channels should be 320, 640 or 1280");
        }
        if (inputs[1].dims.length !== 1) {
          throw new Error("bias is expected to have 1 dimensions");
        }
        if (inputs[0].dims[2] !== inputs[1].dims[0]) {
          throw new Error("last dimension of input and bias are not the same");
        }
      };
      createBiasAddProgramInfo = (inputs) => {
        const outputShape = inputs[0].dims;
        const channels = inputs[0].dims[2];
        const outputSize = ShapeUtil.size(outputShape) / 4;
        const dataType = inputs[0].dataType;
        const input = inputVariable("input", dataType, outputShape, 4);
        const bias = inputVariable("bias", dataType, [channels], 4);
        const residual = inputVariable("residual", dataType, outputShape, 4);
        const output = outputVariable("output", dataType, outputShape, 4);
        const getShaderSource = (shaderHelper) => `
  const channels = ${channels}u / 4;
  ${shaderHelper.declareVariables(input, bias, residual, output)}

  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}
    let value = ${input.getByOffset("global_idx")}
      + ${bias.getByOffset("global_idx % channels")} + ${residual.getByOffset("global_idx")};
    ${output.setByOffset("global_idx", "value")}
  }`;
        return {
          name: "BiasAdd",
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) }
          }),
          getShaderSource
        };
      };
      biasAdd = (context) => {
        validateInputs5(context.inputs);
        context.compute(createBiasAddProgramInfo(context.inputs));
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/unary-op.ts
  var createElementwiseProgramShader, createElementwiseProgramInfo, abs, acos, acosh, asin, asinh, atan, atanh, parseCastAttributes, cast, generateClipAttributesFromInputs, clip, ceil, cos, cosh, parseAlphaAttributes, elu, erfImpl, erf, exp, floor, gelu, leakyRelu, not, neg, reciprocal, relu, sigmoid, parseHardSigmoidAttributes, hardSigmoid, sin, sinh, sqrt, tan, tanhExpression, tanh, fastGeluImpl, fastGeluExpression, fastGelu, thresholdedRelu, log, quickGeluImpl, quickGeluExpression, quickgelu;
  var init_unary_op = __esm({
    "web/lib/wasm/jsep/webgpu/ops/unary-op.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      createElementwiseProgramShader = (shaderHelper, datasize, inputDataType, outputDataType, funcCall, additionalImplementation, additionalUniformsType) => {
        const vecSize = Math.ceil(datasize / 4);
        let expression = "";
        if (typeof funcCall === "string") {
          expression = `${funcCall}(a)`;
        } else {
          expression = funcCall("a");
        }
        const input = inputVariable("inputData", inputDataType, [vecSize], 4);
        const output = outputVariable("outputData", outputDataType, [vecSize], 4);
        const uniforms = [{ name: "vec_size", type: "u32" }];
        if (additionalUniformsType) {
          uniforms.push(...additionalUniformsType);
        }
        return `
      ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}

  ${additionalImplementation ?? ""}

  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.vec_size")}

    let a = ${input.getByOffset("global_idx")};
    ${output.setByOffset("global_idx", expression)}
  }`;
      };
      createElementwiseProgramInfo = (input, name, funcCall, additionalImplementation, cacheKey, outputDataType = input.dataType, additionalUniforms, additionalUniformsType) => {
        const programUniforms = [
          { type: 12 /* uint32 */, data: Math.ceil(ShapeUtil.size(input.dims) / 4) }
        ];
        if (additionalUniforms) {
          programUniforms.push(...additionalUniforms);
        }
        return {
          name,
          shaderCache: { hint: cacheKey, inputDependencies: ["type"] },
          getShaderSource: (shaderHelper) => createElementwiseProgramShader(
            shaderHelper,
            ShapeUtil.size(input.dims),
            input.dataType,
            outputDataType,
            funcCall,
            additionalImplementation,
            additionalUniformsType
          ),
          getRunData: (inputTensors) => ({
            outputs: [{ dims: input.dims, dataType: outputDataType }],
            dispatchGroup: {
              x: Math.ceil(
                ShapeUtil.size(inputTensors[0].dims) / 64 / 4
                /* vec size */
              )
            },
            programUniforms
          })
        };
      };
      abs = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Abs", "abs"));
      };
      acos = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Acos", "acos"));
      };
      acosh = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Acosh", "acosh"));
      };
      asin = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Asin", "asin"));
      };
      asinh = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Asinh", "asinh"));
      };
      atan = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Atan", "atan"));
      };
      atanh = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Atanh", "atanh"));
      };
      parseCastAttributes = (attributes) => createAttributeWithCacheKey(attributes);
      cast = (context, attributes) => {
        let func;
        switch (attributes.to) {
          case 10 /* float16 */:
            func = "vec4<f16>";
            break;
          case 1 /* float */:
            func = "vec4<f32>";
            break;
          case 12 /* uint32 */:
            func = "vec4<u32>";
            break;
          case 6 /* int32 */:
            func = "vec4<i32>";
            break;
          case 9 /* bool */:
            func = "vec4<bool>";
            break;
          default:
            throw new RangeError(`not supported type (specified in attribute 'to' from 'Cast' operator): ${attributes.to}`);
        }
        context.compute(
          createElementwiseProgramInfo(context.inputs[0], "Cast", func, void 0, attributes.cacheKey, attributes.to)
        );
      };
      generateClipAttributesFromInputs = (inputs) => {
        let min;
        let max;
        const hasMin = inputs.length >= 2 && inputs[1].data !== 0;
        const hasMax = inputs.length >= 3 && inputs[2].data !== 0;
        switch (inputs[0].dataType) {
          case 1 /* float */:
            min = hasMin ? inputs[1].getFloat32Array()[0] : -34028234663852886e22;
            max = hasMax ? inputs[2].getFloat32Array()[0] : 34028234663852886e22;
            break;
          case 10 /* float16 */:
            min = hasMin ? inputs[1].getUint16Array()[0] : 64511;
            max = hasMax ? inputs[2].getUint16Array()[0] : 31743;
            break;
          default:
            throw new Error("Unsupport data type");
        }
        return createAttributeWithCacheKey({ min, max });
      };
      clip = (context, clipAttributes) => {
        const attributes = clipAttributes ? clipAttributes : generateClipAttributesFromInputs(context.inputs);
        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);
        context.compute(
          createElementwiseProgramInfo(
            context.inputs[0],
            "Clip",
            (a) => `clamp(${a}, vec4<${dataType}>(uniforms.min), vec4<${dataType}>(uniforms.max))`,
            void 0,
            attributes.cacheKey,
            void 0,
            [
              { type: context.inputs[0].dataType, data: attributes.min },
              { type: context.inputs[0].dataType, data: attributes.max }
            ],
            [
              { name: "min", type: dataType },
              { name: "max", type: dataType }
            ]
          ),
          { inputs: [0] }
        );
      };
      ceil = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Ceil", "ceil"));
      };
      cos = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Cos", "cos"));
      };
      cosh = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Cosh", "cosh"));
      };
      parseAlphaAttributes = (attributes) => createAttributeWithCacheKey(attributes);
      elu = (context, attributes) => {
        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);
        context.compute(
          createElementwiseProgramInfo(
            context.inputs[0],
            "Elu",
            (a) => `elu_vf32(${a})`,
            `
  const elu_alpha_ = ${dataType}(${attributes.alpha});

  fn elu_f32(a: ${dataType}) -> ${dataType} {
  return select((exp(a) - 1.0) * elu_alpha_, a, a >= 0.0);
  }

  fn elu_vf32(v: vec4<${dataType}>) -> vec4<${dataType}> {
  return vec4(elu_f32(v.x), elu_f32(v.y), elu_f32(v.z), elu_f32(v.w));
  }`,
            attributes.cacheKey
          )
        );
      };
      erfImpl = (varType = "f32") => `
const r0: ${varType} = 0.3275911;
const r1: ${varType} = 0.254829592;
const r2: ${varType} = -0.284496736;
const r3: ${varType} = 1.421413741;
const r4: ${varType} = -1.453152027;
const r5: ${varType} = 1.061405429;

fn erf_vf32(v: vec4<${varType}>) -> vec4<${varType}> {
  let absv = abs(v);
  let x = 1.0 / (1.0 + r0 * absv);
  return sign(v) * (1.0 - ((((r5 * x + r4) * x + r3) * x + r2) * x + r1) * x * exp(-absv * absv));
}`;
      erf = (context) => {
        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Erf", (a) => `erf_vf32(${a})`, erfImpl(dataType)));
      };
      exp = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Exp", "exp"));
      };
      floor = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Floor", "floor"));
      };
      gelu = (context) => {
        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);
        context.compute(
          createElementwiseProgramInfo(
            context.inputs[0],
            "Gelu",
            (a) => `0.5 * ${a} * (1.0 + erf_vf32(${a} * 0.7071067811865475))`,
            erfImpl(dataType)
          )
        );
      };
      leakyRelu = (context, attributes) => {
        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);
        context.compute(
          createElementwiseProgramInfo(
            context.inputs[0],
            "LeakyRelu",
            (a) => `select(leaky_relu_alpha_ * ${a}, ${a}, ${a} >= vec4<${dataType}>(0.0))`,
            `const leaky_relu_alpha_ = ${dataType}(${attributes.alpha});`,
            attributes.cacheKey
          )
        );
      };
      not = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Not", (a) => `!${a}`));
      };
      neg = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Neg", (a) => `-${a}`));
      };
      reciprocal = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Reciprocal", (a) => `1.0/${a}`));
      };
      relu = (context) => {
        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);
        context.compute(
          createElementwiseProgramInfo(
            context.inputs[0],
            "Relu",
            (a) => `select(vec4<${dataType}>(0.0), ${a}, ${a} > vec4<${dataType}>(0.0))`
          )
        );
      };
      sigmoid = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Sigmoid", (a) => `(1.0 / (1.0 + exp(-${a})))`));
      };
      parseHardSigmoidAttributes = (attributes) => createAttributeWithCacheKey(
        attributes
      );
      hardSigmoid = (context, attributes) => {
        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);
        context.compute(
          createElementwiseProgramInfo(
            context.inputs[0],
            "HardSigmoid",
            (a) => `max(vec4<${dataType}>(0.0), min(vec4<${dataType}>(1.0), ${attributes.alpha} * ${a} + vec4<${dataType}>(${attributes.beta})))`,
            void 0,
            attributes.cacheKey
          )
        );
      };
      sin = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Sin", "sin"));
      };
      sinh = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Sinh", "sinh"));
      };
      sqrt = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Sqrt", "sqrt"));
      };
      tan = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Tan", "tan"));
      };
      tanhExpression = (a) => `sign(${a}) * (1 - exp(-2 * abs(${a}))) / (1 + exp(-2 * abs(${a})))`;
      tanh = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Tanh", tanhExpression));
      };
      fastGeluImpl = (varType = "f32") => `
const fast_gelu_a: ${varType} = 0.5;
const fast_gelu_b: ${varType} = 0.7978845608028654;
const fast_gelu_c: ${varType} = 0.035677408136300125;

fn tanh_v(v: vec4<${varType}>) -> vec4<${varType}> {
  return ${tanhExpression("v")};
}
`;
      fastGeluExpression = (x) => `(fast_gelu_a + fast_gelu_a * tanh_v(${x} * (fast_gelu_c * ${x} * ${x} + fast_gelu_b))) * ${x}`;
      fastGelu = (context) => {
        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);
        context.compute(
          createElementwiseProgramInfo(
            context.inputs[0],
            "FastGelu",
            fastGeluExpression,
            fastGeluImpl(dataType),
            void 0,
            context.inputs[0].dataType
          )
        );
      };
      thresholdedRelu = (context, attributes) => {
        const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);
        context.compute(
          createElementwiseProgramInfo(
            context.inputs[0],
            "ThresholdedRelu",
            (a) => `select(vec4<${dataType}>(0.0), ${a}, ${a} > thresholded_relu_alpha_)`,
            `const thresholded_relu_alpha_ = vec4<${dataType}>(${attributes.alpha});`,
            attributes.cacheKey
          )
        );
        return 0;
      };
      log = (context) => {
        context.compute(createElementwiseProgramInfo(context.inputs[0], "Log", "log"));
      };
      quickGeluImpl = (varType, alpha) => `
const alpha = vec4<${varType}>(${alpha});
const one = ${varType}(1.0);
const zero = ${varType}(0.0);

fn quick_gelu_impl(x: vec4<${varType}>) -> vec4<${varType}> {
  let v = x *alpha;
  var x1 : vec4<${varType}>;
  for (var i = 0; i < 4; i = i + 1) {
    if (v[i] >= zero) {
      x1[i] = one / (one + exp(-v[i]));
    } else {
      x1[i] = one - one / (one + exp(v[i]));
    }
  }
  return x * x1;
}
`;
      quickGeluExpression = (x) => `quick_gelu_impl(${x})`;
      quickgelu = (context, attributes) => {
        const dType = tensorTypeToWsglValueType(context.inputs[0].dataType);
        context.compute(
          createElementwiseProgramInfo(
            context.inputs[0],
            "QuickGelu",
            quickGeluExpression,
            quickGeluImpl(dType, attributes.alpha),
            attributes.cacheKey,
            context.inputs[0].dataType
          )
        );
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/bias-split-gelu.ts
  var validateInputs6, createBiasSplitGeluProgramInfo, biasSplitGelu;
  var init_bias_split_gelu = __esm({
    "web/lib/wasm/jsep/webgpu/ops/bias-split-gelu.ts"() {
      "use strict";
      init_util();
      init_common();
      init_unary_op();
      validateInputs6 = (inputs) => {
        if (inputs[0].dims.length !== 3) {
          throw new Error("input should have 3 dimensions");
        }
        if (![2560, 5120, 10240].includes(inputs[0].dims[2])) {
          throw new Error("hidden state should be 2560, 5120 or 10240");
        }
        if (inputs[1].dims.length !== 1) {
          throw new Error("bias is expected to have 1 dimensions");
        }
        if (inputs[0].dims[2] !== inputs[1].dims[0]) {
          throw new Error("last dimension of input and bias are not the same");
        }
      };
      createBiasSplitGeluProgramInfo = (inputs) => {
        const outputShape = inputs[0].dims.slice();
        outputShape[2] = outputShape[2] / 2;
        const input = inputVariable("input", inputs[0].dataType, inputs[0].dims, 4);
        const bias = inputVariable("bias", inputs[0].dataType, [inputs[0].dims[2]], 4);
        const output = outputVariable("output", inputs[0].dataType, outputShape, 4);
        const outputSize = ShapeUtil.size(outputShape) / 4;
        const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);
        const getShaderSource = (shaderHelper) => `
  const M_SQRT2 = sqrt(2.0);
  const halfChannels = ${inputs[0].dims[2] / 4 / 2}u;

  ${shaderHelper.declareVariables(input, bias, output)}

  ${erfImpl(dataType)}

  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}
    let biasIdx = global_idx % halfChannels;
    let batchIndex = global_idx / halfChannels;
    let inputOffset = biasIdx + batchIndex * halfChannels * 2;
    let valueLeft = input[inputOffset] + bias[biasIdx];
    let valueRight = input[inputOffset + halfChannels] + bias[biasIdx + halfChannels];
    let geluRight = valueRight * 0.5 * (erf_vf32(valueRight / M_SQRT2) + 1);

    ${output.setByOffset("global_idx", "valueLeft * geluRight")}
  }`;
        return {
          name: "BiasSplitGelu",
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) }
          }),
          getShaderSource
        };
      };
      biasSplitGelu = (context) => {
        validateInputs6(context.inputs);
        context.compute(createBiasSplitGeluProgramInfo(context.inputs));
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/binary-op.ts
  var createBinaryOpProgramShader, createBinaryOpProgramInfo, runBinaryOp, add, div, equal, mul, pow, sub, greater, less, greaterOrEqual, lessOrEqual;
  var init_binary_op = __esm({
    "web/lib/wasm/jsep/webgpu/ops/binary-op.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_common();
      createBinaryOpProgramShader = (shaderHelper, dimsA, dimsB, dimsOutput, vectorize, doBroadcast, sharedDimensionDivisibleBy4, funcCall, typeA, typeB, typeOutput, additionalImplementation) => {
        let expressionScalar;
        let expressionVector;
        if (typeof funcCall === "string") {
          expressionScalar = expressionVector = (a2, b2) => `${funcCall}((${a2}),(${b2}))`;
        } else if (typeof funcCall === "function") {
          expressionScalar = expressionVector = funcCall;
        } else {
          expressionScalar = funcCall.scalar;
          expressionVector = funcCall.vector;
        }
        const output = outputVariable("outputData", typeOutput, dimsOutput.length, 4);
        const a = inputVariable("aData", typeA, dimsA.length, 4);
        const b = inputVariable("bData", typeB, dimsB.length, 4);
        let assignment;
        if (vectorize) {
          if (doBroadcast) {
            const isAOneElement = ShapeUtil.size(dimsA) === 1;
            const isBOneElement = ShapeUtil.size(dimsB) === 1;
            const aLastDimDivisibleBy4 = dimsA.length > 0 && dimsA[dimsA.length - 1] % 4 === 0;
            const bLastDimDivisibleBy4 = dimsB.length > 0 && dimsB[dimsB.length - 1] % 4 === 0;
            if (isAOneElement || isBOneElement) {
              assignment = output.setByOffset(
                "global_idx",
                expressionVector(
                  isAOneElement ? `${a.type.value}(${a.getByOffset("0")}.x)` : a.getByOffset("global_idx"),
                  isBOneElement ? `${b.type.value}(${b.getByOffset("0")}.x)` : b.getByOffset("global_idx")
                )
              );
            } else {
              assignment = `
            let outputIndices = ${output.offsetToIndices("global_idx * 4u")};
            let offsetA = ${a.broadcastedIndicesToOffset("outputIndices", output)};
            let offsetB = ${b.broadcastedIndicesToOffset("outputIndices", output)};
            ${output.setByOffset(
                "global_idx",
                expressionVector(
                  sharedDimensionDivisibleBy4 || aLastDimDivisibleBy4 ? a.getByOffset("offsetA / 4u") : `${a.type.value}(${a.getByOffset("offsetA / 4u")}[offsetA % 4u])`,
                  sharedDimensionDivisibleBy4 || bLastDimDivisibleBy4 ? b.getByOffset("offsetB / 4u") : `${b.type.value}(${b.getByOffset("offsetB / 4u")}[offsetB % 4u])`
                )
              )}
          `;
            }
          } else {
            assignment = output.setByOffset(
              "global_idx",
              expressionVector(a.getByOffset("global_idx"), b.getByOffset("global_idx"))
            );
          }
        } else {
          if (!doBroadcast) {
            throw new Error("no necessary to use scalar implementation for element-wise binary op implementation.");
          }
          const singleAssignment = (resStr, x, typeCast = "") => {
            const expressionA = `aData[indexA${x}][componentA${x}]`;
            const expressionB = `bData[indexB${x}][componentB${x}]`;
            return `
            let outputIndices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)};
            let offsetA${x} = ${a.broadcastedIndicesToOffset(`outputIndices${x}`, output)};
            let offsetB${x} = ${b.broadcastedIndicesToOffset(`outputIndices${x}`, output)};
            let indexA${x} = offsetA${x} / 4u;
            let indexB${x} = offsetB${x} / 4u;
            let componentA${x} = offsetA${x} % 4u;
            let componentB${x} = offsetB${x} % 4u;
            ${resStr}[${x}] = ${typeCast}(${expressionScalar(expressionA, expressionB)});
          `;
          };
          if (typeOutput === 9 /* bool */) {
            assignment = `
            var data = vec4<u32>(0);
            ${singleAssignment("data", 0, "u32")}
            ${singleAssignment("data", 1, "u32")}
            ${singleAssignment("data", 2, "u32")}
            ${singleAssignment("data", 3, "u32")}
            outputData[global_idx] = dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(data));`;
          } else {
            assignment = `
            ${singleAssignment("outputData[global_idx]", 0)}
            ${singleAssignment("outputData[global_idx]", 1)}
            ${singleAssignment("outputData[global_idx]", 2)}
            ${singleAssignment("outputData[global_idx]", 3)}
          `;
          }
        }
        return `
        ${shaderHelper.registerUniform("vec_size", "u32").declareVariables(a, b, output)}

        ${additionalImplementation ?? ""}

        ${shaderHelper.mainStart()}
        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.vec_size")}
        ${assignment}
      }`;
      };
      createBinaryOpProgramInfo = (name, cacheKey, a, b, funcCall, additionalImplementation, outputDataType = a.dataType) => {
        const aDims = a.dims.map(Number);
        const bDims = b.dims.map(Number);
        const isBroadcast = !ShapeUtil.areEqual(aDims, bDims);
        let outputShape = aDims;
        let outputSize = ShapeUtil.size(aDims);
        let vectorize = false;
        let sharedDimensionDivisibleBy4 = false;
        const cacheKeyAux = [isBroadcast];
        if (isBroadcast) {
          const calculatedShape = BroadcastUtil.calcShape(aDims, bDims, false);
          if (!calculatedShape) {
            throw new Error("Can't perform binary op on the given tensors");
          }
          outputShape = calculatedShape.slice();
          outputSize = ShapeUtil.size(outputShape);
          const isAOneElement = ShapeUtil.size(aDims) === 1;
          const isBOneElement = ShapeUtil.size(bDims) === 1;
          const aLastDimDivisibleBy4 = aDims.length > 0 && aDims[aDims.length - 1] % 4 === 0;
          const bLastDimDivisibleBy4 = bDims.length > 0 && bDims[bDims.length - 1] % 4 === 0;
          cacheKeyAux.push(isAOneElement);
          cacheKeyAux.push(isBOneElement);
          cacheKeyAux.push(aLastDimDivisibleBy4);
          cacheKeyAux.push(bLastDimDivisibleBy4);
          let sharedDimension = 1;
          for (let i = 1; i < outputShape.length; i++) {
            const dimA = aDims[aDims.length - i];
            const dimB = bDims[bDims.length - i];
            if (dimA === dimB) {
              sharedDimension *= dimA;
            } else {
              break;
            }
          }
          if (sharedDimension % 4 === 0) {
            sharedDimensionDivisibleBy4 = true;
            vectorize = true;
          } else if (isAOneElement || isBOneElement || aLastDimDivisibleBy4 || bLastDimDivisibleBy4) {
            vectorize = true;
          }
        } else {
          vectorize = true;
        }
        cacheKeyAux.push(vectorize);
        return {
          name,
          shaderCache: {
            hint: cacheKey + cacheKeyAux.map((x) => x.toString()).join("_"),
            inputDependencies: ["rank", "rank"]
          },
          getShaderSource: (shaderHelper) => createBinaryOpProgramShader(
            shaderHelper,
            aDims,
            bDims,
            outputShape,
            vectorize,
            isBroadcast,
            sharedDimensionDivisibleBy4,
            funcCall,
            a.dataType,
            b.dataType,
            outputDataType,
            additionalImplementation
          ),
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: outputDataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64 / 4
              /* component size */
            ) },
            programUniforms: [
              { type: 12 /* uint32 */, data: Math.ceil(ShapeUtil.size(outputShape) / 4) },
              ...createTensorShapeVariables(aDims, bDims, outputShape)
            ]
          })
        };
      };
      runBinaryOp = (context, name, funcCall, additionalImplementation, cacheKey, outputDataType) => {
        context.compute(
          createBinaryOpProgramInfo(
            name,
            cacheKey ?? "",
            context.inputs[0],
            context.inputs[1],
            funcCall,
            additionalImplementation,
            outputDataType
          )
        );
      };
      add = (context) => {
        runBinaryOp(context, "Add", (a, b) => `${a}+${b}`);
      };
      div = (context) => {
        runBinaryOp(context, "Div", (a, b) => `${a}/${b}`);
      };
      equal = (context) => {
        runBinaryOp(
          context,
          "Equal",
          { scalar: (a, b) => `u32(${a}==${b})`, vector: (a, b) => `vec4<u32>(${a}==${b})` },
          void 0,
          void 0,
          9 /* bool */
        );
      };
      mul = (context) => {
        runBinaryOp(context, "Mul", (a, b) => `${a}*${b}`);
      };
      pow = (context) => {
        const type = inputVariable("input", context.inputs[0].dataType, context.inputs[0].dims).type.value;
        const roundStr = type === "i32" ? "round" : "";
        runBinaryOp(
          context,
          "Pow",
          { scalar: (a, b) => `pow_custom(${a},${b})`, vector: (a, b) => `pow_vector_custom(${a},${b})` },
          `
    fn pow_custom(a : ${type}, b : ${type}) -> ${type} {
      if (b == ${type}(0.0)) {
        return ${type}(1.0);
      } else if (a < ${type}(0.0) && f32(b) != floor(f32(b))) {
        return ${type}(pow(f32(a), f32(b))); // NaN
      }
      return select(sign(a), ${type}(1.0), round(f32(abs(b) % ${type}(2.0))) != 1.0) * ${type}(${roundStr}(pow(f32(abs(a)), f32(b))));
    }
    fn pow_vector_custom(a : vec4<${type}>, b : vec4<${type}>) -> vec4<${type}> {
      // TODO: implement vectorized pow
      return vec4<${type}>(pow_custom(a.x, b.x), pow_custom(a.y, b.y), pow_custom(a.z, b.z), pow_custom(a.w, b.w));
    }
      `
        );
      };
      sub = (context) => {
        runBinaryOp(context, "Sub", (a, b) => `${a}-${b}`);
      };
      greater = (context) => {
        runBinaryOp(
          context,
          "Greater",
          { scalar: (a, b) => `u32(${a}>${b})`, vector: (a, b) => `vec4<u32>(${a}>${b})` },
          void 0,
          void 0,
          9 /* bool */
        );
      };
      less = (context) => {
        runBinaryOp(
          context,
          "Less",
          { scalar: (a, b) => `u32(${a}<${b})`, vector: (a, b) => `vec4<u32>(${a}<${b})` },
          void 0,
          void 0,
          9 /* bool */
        );
      };
      greaterOrEqual = (context) => {
        runBinaryOp(
          context,
          "GreaterOrEqual",
          { scalar: (a, b) => `u32(${a}>=${b})`, vector: (a, b) => `vec4<u32>(${a}>=${b})` },
          void 0,
          void 0,
          9 /* bool */
        );
      };
      lessOrEqual = (context) => {
        runBinaryOp(
          context,
          "LessOrEqual",
          { scalar: (a, b) => `u32(${a}<=${b})`, vector: (a, b) => `vec4<u32>(${a}<=${b})` },
          void 0,
          void 0,
          9 /* bool */
        );
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/concat.ts
  var validateInputs7, calculateInputIndexImpl, assignOutputData, createConcatProgramInfo, concat, parseConcatAttributes;
  var init_concat = __esm({
    "web/lib/wasm/jsep/webgpu/ops/concat.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      validateInputs7 = (inputs, axis) => {
        if (!inputs || inputs.length < 1) {
          throw new Error("too few inputs");
        }
        const referenceIndex = 0;
        const referenceInput = inputs[referenceIndex];
        const inputType = referenceInput.dataType;
        const inputRank = referenceInput.dims.length;
        inputs.forEach((input, i) => {
          if (i === referenceIndex) {
            return;
          }
          if (input.dataType !== inputType) {
            throw new Error("input tensors should be one type");
          }
          if (input.dims.length !== inputRank) {
            throw new Error("input tensors should have the same shape");
          }
          input.dims.forEach((dim, i2) => {
            if (i2 !== axis && dim !== referenceInput.dims[i2]) {
              throw new Error("non concat dimensions must match");
            }
          });
        });
      };
      calculateInputIndexImpl = (numberOfTensors, sizeInConcatAxisStr) => `
  fn calculateInputIndex(index: u32) -> u32 {
    let sizeInConcatAxis = array<u32, ${numberOfTensors}u>(${sizeInConcatAxisStr});
    for (var i: u32 = 0u; i < ${numberOfTensors}; i += 1u ) {
      if (index < sizeInConcatAxis[i]) {
        return i;
      }
    }
    return ${numberOfTensors}u;
  }`;
      assignOutputData = (inputs, output) => {
        const numberOfTensors = inputs.length;
        const codeLines = [];
        for (let i = 0; i < numberOfTensors; ++i) {
          const returnSnippet = output.setByOffset("global_idx", inputs[i].getByIndices("indices"));
          if (numberOfTensors === 1) {
            codeLines.push(returnSnippet);
          } else if (i === 0) {
            codeLines.push(`if (inputIndex == ${i}u) { ${returnSnippet} }`);
          } else if (i === numberOfTensors - 1) {
            codeLines.push(`else { ${returnSnippet} }`);
          } else {
            codeLines.push(`else if (inputIndex == ${i}) { ${returnSnippet} }`);
          }
        }
        return codeLines.join("\n");
      };
      createConcatProgramInfo = (inputs, adjustedAxis, outputShape, dataType) => {
        const outputSize = ShapeUtil.size(outputShape);
        const sizeInConcatAxis = new Array(inputs.length);
        const inputVars = new Array(inputs.length);
        let previousSum = 0;
        const inputDependencies = [];
        const inputRanks = [];
        const programUniforms = [{ type: 12 /* uint32 */, data: outputSize }];
        for (let i = 0; i < inputs.length; ++i) {
          previousSum += inputs[i].dims[adjustedAxis];
          sizeInConcatAxis[i] = previousSum;
          inputRanks.push(inputs[i].dims.length);
          inputVars[i] = inputVariable(`input${i}`, dataType, inputRanks[i]);
          inputDependencies.push("rank");
          programUniforms.push({ type: 12 /* uint32 */, data: sizeInConcatAxis[i] });
        }
        for (let i = 0; i < inputs.length; ++i) {
          programUniforms.push(...createTensorShapeVariables(inputs[i].dims));
        }
        programUniforms.push(...createTensorShapeVariables(outputShape));
        const output = outputVariable("output", dataType, outputShape.length);
        const indicesAxis = output.indicesGet("indices", adjustedAxis);
        const sizeInConcatAxisStr = Array.from(Array(sizeInConcatAxis.length).keys()).map((i) => `uniforms.sizeInConcatAxis${i}`).join(",");
        const getShaderSource = (shaderHelper) => `

  ${(() => {
          shaderHelper.registerUniform("outputSize", "u32");
          for (let i = 0; i < inputs.length; i++) {
            shaderHelper.registerUniform(`sizeInConcatAxis${i}`, "u32");
          }
          return shaderHelper.declareVariables(...inputVars, output);
        })()}

  ${calculateInputIndexImpl(sizeInConcatAxis.length, sizeInConcatAxisStr)}

  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}

    var indices = ${output.offsetToIndices("global_idx")};

    let inputIndex = calculateInputIndex(${indicesAxis});
    if (inputIndex != 0u) {
      let sizeInConcatAxis = array<u32, ${sizeInConcatAxis.length}u>(${sizeInConcatAxisStr});
      ${indicesAxis} -= sizeInConcatAxis[inputIndex - 1u];
    }

    ${assignOutputData(inputVars, output)}
  }`;
        return {
          name: "Concat",
          shaderCache: { hint: `${adjustedAxis}`, inputDependencies },
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms
          }),
          getShaderSource
        };
      };
      concat = (context, attributes) => {
        const inputs = context.inputs;
        const inputShape = inputs[0].dims;
        const adjustedAxis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);
        validateInputs7(inputs, adjustedAxis);
        const outputShape = inputShape.slice();
        outputShape[adjustedAxis] = inputs.reduce(
          (sum, input) => sum + (input.dims.length > adjustedAxis ? input.dims[adjustedAxis] : 0),
          0
        );
        const nonEmptyInputs = inputs.filter((input) => ShapeUtil.size(input.dims) > 0);
        context.compute(createConcatProgramInfo(nonEmptyInputs, adjustedAxis, outputShape, inputs[0].dataType), {
          inputs: nonEmptyInputs
        });
      };
      parseConcatAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis });
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/fuse-utils.ts
  var getActivationSnippet, appendActivationUniformsData, appendActivationUniforms, parseInternalActivationAttributes;
  var init_fuse_utils = __esm({
    "web/lib/wasm/jsep/webgpu/ops/fuse-utils.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      getActivationSnippet = (attributes, valueType, baseType = "f32") => {
        switch (attributes.activation) {
          case "Relu":
            return `value = max(value, ${valueType}(0.0));`;
          case "Sigmoid":
            return `value = (${valueType}(1.0) / (${valueType}(1.0) + exp(-value)));`;
          case "Clip":
            return `value = clamp(value, ${valueType}(${baseType}(uniforms.clip_min)), ${valueType}(${baseType}(uniforms.clip_max)));`;
          case "HardSigmoid":
            return `value = max(${valueType}(0.0), min(${valueType}(1.0), ${baseType}(uniforms.alpha) * value + ${baseType}(uniforms.beta)));`;
          case "LeakyRelu":
            return `value = select(${baseType}(uniforms.alpha) * value, value, value >= ${valueType}(0.0));`;
          case "Tanh":
            return `let e2x = exp(-2.0 * abs(value));
              value = sign(value) * (1.0 - e2x) / (1.0 + e2x);
        `;
          case "":
            return "";
          // TODO: adding other activations that can be fused.
          default:
            throw new Error(`Unsupported activation ${attributes.activation}`);
        }
      };
      appendActivationUniformsData = (attributes, programUniform) => {
        if (attributes.activation === "Clip") {
          programUniform.push(
            { type: 1 /* float */, data: attributes.clipMax },
            { type: 1 /* float */, data: attributes.clipMin }
          );
        } else if (attributes.activation === "HardSigmoid") {
          programUniform.push(
            { type: 1 /* float */, data: attributes.alpha },
            { type: 1 /* float */, data: attributes.beta }
          );
        } else if (attributes.activation === "LeakyRelu") {
          programUniform.push({ type: 1 /* float */, data: attributes.alpha });
        }
      };
      appendActivationUniforms = (attributes, uniforms) => {
        if (attributes.activation === "Clip") {
          uniforms.push({ name: "clip_max", type: "f32" }, { name: "clip_min", type: "f32" });
        } else if (attributes.activation === "HardSigmoid") {
          uniforms.push({ name: "alpha", type: "f32" }, { name: "beta", type: "f32" });
        } else if (attributes.activation === "LeakyRelu") {
          uniforms.push({ name: "alpha", type: "f32" });
        }
      };
      parseInternalActivationAttributes = (attributes) => {
        const activation = attributes?.activation || "";
        if (activation === "HardSigmoid") {
          const [alpha, beta] = attributes?.activation_params || [0.2, 0.5];
          return { activation, alpha, beta };
        } else if (activation === "Clip") {
          const [clipMin, clipMax] = attributes?.activation_params || [MIN_CLIP, MAX_CLIP];
          return { activation, clipMax, clipMin };
        } else if (activation === "LeakyRelu") {
          const [alpha] = attributes?.activation_params || [0.01];
          return { activation, alpha };
        }
        return { activation };
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/3rd-party/activation_util.ts
  var typeSnippet, biasSnippet;
  var init_activation_util = __esm({
    "web/lib/wasm/jsep/webgpu/ops/3rd-party/activation_util.ts"() {
      "use strict";
      typeSnippet = (component, dataType) => {
        switch (component) {
          case 1:
            return dataType;
          case 2:
            return `vec2<${dataType}>`;
          case 3:
            return `vec3<${dataType}>`;
          case 4:
            return `vec4<${dataType}>`;
          default:
            throw new Error(`${component}-component is not supported.`);
        }
      };
      biasSnippet = (hasBias) => `
      ${hasBias ? "value = value + getBiasByOutputCoords(coords);" : ""}
      `;
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_util.ts
  var utilFunctions;
  var init_conv_util = __esm({
    "web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_util.ts"() {
      "use strict";
      utilFunctions = (strideStr) => `
fn getIndexFromCoords4D(coords : vec4<i32>, shape : vec4<i32>) -> i32 {
  return dot(coords, vec4<i32>(
      shape.y * shape.z * shape.w, shape.z * shape.w, shape.w, 1));
}
fn getOutputIndexFromCoords(coords : vec4<i32>) -> i32 {
  return dot(coords, vec4<i32>(
    i32(${strideStr}.x), i32(${strideStr}.y), i32(${strideStr}.z), 1));
}
`;
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/matmul-shaders.ts
  var convertOutputBatchIndicesToInputBatchIndices, createNaiveMatmulProgramInfo;
  var init_matmul_shaders = __esm({
    "web/lib/wasm/jsep/webgpu/ops/matmul-shaders.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_common();
      init_fuse_utils();
      convertOutputBatchIndicesToInputBatchIndices = (targetIndicesName, inputVariable2, inputBatchRank, outputBatchRank, batchIndicesName) => {
        const extendingInputRank = outputBatchRank - inputBatchRank;
        return `
      ${Array.from({ length: inputBatchRank }).map(
          (_, i) => `
      if (${getElementAt(inputVariable2.shape, i, inputVariable2.rank)} != 1) {
        ${inputVariable2.indicesSet(targetIndicesName, i, getElementAt(batchIndicesName, i + extendingInputRank, outputBatchRank))}
      } else {
        ${inputVariable2.indicesSet(targetIndicesName, i, 0)}
      }`
        ).join("")}
`;
      };
      createNaiveMatmulProgramInfo = (inputs, activationAttributes, outputShape, reshapedOutputShape, isChannelsLast = false, squeezeOutputShapeFunction) => {
        const aShape = inputs[0].dims;
        const bShape = inputs[1].dims;
        const M = aShape[aShape.length - 2];
        const N = bShape[bShape.length - 1];
        const K = aShape[aShape.length - 1];
        const components = getMaxComponents(N);
        const aComponents = getMaxComponents(K);
        const outputNumber = getMaxComponents(M);
        const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;
        const hasBias = inputs.length > 2;
        const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2);
        const batchSize = ShapeUtil.size(outerDims);
        const outputShapeInShader = [batchSize, M, N];
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 12 /* uint32 */, data: M },
          { type: 12 /* uint32 */, data: N },
          { type: 12 /* uint32 */, data: K }
        ];
        appendActivationUniformsData(activationAttributes, programUniforms);
        programUniforms.push(...createTensorShapeVariables(outerDims, aShape, bShape));
        if (hasBias) {
          programUniforms.push(...createTensorShapeVariables(inputs[2].dims));
        }
        programUniforms.push(...createTensorShapeVariables(outputShapeInShader));
        const getShaderSource = (shaderHelper) => {
          const batchDims = internalVariable("batch_dims", inputs[0].dataType, outerDims.length);
          const a = inputVariable("a", inputs[0].dataType, aShape.length, aComponents);
          const b = inputVariable("b", inputs[1].dataType, bShape.length, components);
          const output = outputVariable("output", inputs[0].dataType, outputShapeInShader.length, components);
          const baseType = tensorTypeToWsglStorageType(output.type.tensor);
          const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType);
          const inputVariables = [a, b];
          let processBias = "";
          if (hasBias) {
            const biasComponents = isChannelsLast ? components : 1;
            inputVariables.push(inputVariable("bias", inputs[2].dataType, inputs[2].dims.length, biasComponents));
            processBias = `${isChannelsLast ? `value += bias[col / ${biasComponents}];` : `value += ${output.type.value}(bias[row + i]);`}`;
          }
          const uniforms = [
            { name: "output_size", type: "u32" },
            { name: "M", type: "u32" },
            { name: "N", type: "u32" },
            { name: "K", type: "u32" }
          ];
          appendActivationUniforms(activationAttributes, uniforms);
          const calcResult = () => {
            let calcStr = `var a_data: ${a.type.value};`;
            for (let i = 0; i < aComponents; i++) {
              calcStr += `
              let b_data${i} = b[(b_offset + (k + ${i}) * uniforms.N + col) / ${components}];`;
            }
            for (let i = 0; i < outputNumber; i++) {
              calcStr += `a_data = a[(a_offset + (row + ${i}) * uniforms.K + k) / ${aComponents}];`;
              for (let j = 0; j < aComponents; j++) {
                calcStr += `
            values[${i}] = fma(${b.type.value}(a_data${aComponents === 1 ? "" : `[${j}]`}), b_data${j}, values[${i}]);
`;
              }
            }
            return calcStr;
          };
          return `
  ${shaderHelper.registerUniforms(uniforms).registerInternalVariables(batchDims).declareVariables(...inputVariables, output)}
  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
    let col = (global_idx % (uniforms.N / ${components})) * ${components};
    var index1 = global_idx / (uniforms.N / ${components});
    let stride1 = uniforms.M / ${outputNumber};
    let row = (index1 % stride1) * ${outputNumber};
    let batch = index1 / stride1;

    ${outputShape.length === 2 ? "" : `let batch_indices = ${batchDims.offsetToIndices("batch")};`}

    var a_indices: ${a.type.indices};
    ${convertOutputBatchIndicesToInputBatchIndices("a_indices", a, a.rank - 2, batchDims.rank, "batch_indices")}
    ${a.indicesSet("a_indices", a.rank - 2, 0)}
    ${a.indicesSet("a_indices", a.rank - 1, 0)}
    let a_offset = ${a.indicesToOffset("a_indices")};

    var b_indices: ${b.type.indices};
    ${convertOutputBatchIndicesToInputBatchIndices("b_indices", b, b.rank - 2, batchDims.rank, "batch_indices")}
    ${b.indicesSet("b_indices", b.rank - 2, 0)}
    ${b.indicesSet("b_indices", b.rank - 1, 0)}
    let b_offset = ${b.indicesToOffset("b_indices")};
    var values: array<${output.type.value}, ${outputNumber}>;
    for (var k: u32 = 0u; k < uniforms.K; k = k + ${aComponents}) {
      ${calcResult()}
    }
    for (var i = 0u; i < ${outputNumber}u; i++) {
      var value = values[i];
      ${processBias}
      ${applyActivation}
      let cur_indices = ${output.type.indices}(batch, row + i, col);
      let offset = ${output.indicesToOffset("cur_indices")};
      ${output.setByOffset(`offset / ${components}`, "value")};
    }
  }
  `;
        };
        return {
          name: "MatMulNaive",
          shaderCache: {
            hint: `${activationAttributes.activation};${components};${aComponents};${outputNumber};${isChannelsLast}`,
            inputDependencies: hasBias ? ["rank", "rank", "rank"] : ["rank", "rank"]
          },
          getRunData: () => ({
            outputs: [
              {
                dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,
                dataType: inputs[0].dataType
              }
            ],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms
          }),
          getShaderSource
        };
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/3rd-party/matmul_packed_webgpu.ts
  var writeDataToSubAVec4Snippet, calculateResultSnippet, makeMatMulPackedVec4Source, writeDataToSubASnippet, readDataFromSubASnippet, makeMatMulPackedSource, matMulReadWriteFnSource, createMatmulProgramInfo;
  var init_matmul_packed_webgpu = __esm({
    "web/lib/wasm/jsep/webgpu/ops/3rd-party/matmul_packed_webgpu.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_common();
      init_fuse_utils();
      init_matmul_shaders();
      init_activation_util();
      writeDataToSubAVec4Snippet = (transpose2, batchDims) => {
        if (transpose2) {
          return `
        mm_Asub[inputRow][inputCol] = mm_readA(batch,
          kStart + inputRow,
          globalRowStart / innerElementSize + inputCol${batchDims ? ", batchIndices" : ""});
        `;
        } else {
          return `
        mm_Asub[inputRow][inputCol] = mm_readA(batch,
          globalRow + innerRow,
          kStart / innerElementSize + inputCol${batchDims ? ", batchIndices" : ""});
        `;
        }
      };
      calculateResultSnippet = (transposeA, innerElementSize) => {
        if (transposeA) {
          return `
        let ACached0 = mm_Asub[k * innerElementSize][localRow];
        let ACached1 = mm_Asub[k * innerElementSize + 1][localRow];
        let ACached2 = mm_Asub[k * innerElementSize + 2][localRow];
        ${innerElementSize === 3 ? "" : "let ACached3 = mm_Asub[k * innerElementSize + 3][localRow];"}
        for (var i = 0; i < rowPerThread; i = i + 1) {
          acc[i] = BCached0 * ACached0[i] + acc[i];
          acc[i] = BCached1 * ACached1[i] + acc[i];
          acc[i] = BCached2 * ACached2[i] + acc[i];
          ${innerElementSize === 3 ? "" : "acc[i] = BCached3 * ACached3[i] + acc[i];"}
        }`;
        } else {
          return `
        for (var i = 0; i < rowPerThread; i = i + 1) {
          let ACached = mm_Asub[tileRow + i][k];
          acc[i] = BCached0 * ACached.x + acc[i];
          acc[i] = BCached1 * ACached.y + acc[i];
          acc[i] = BCached2 * ACached.z + acc[i];
          ${innerElementSize === 3 ? "" : "acc[i] = BCached3 * ACached.w + acc[i];"}
        }`;
        }
      };
      makeMatMulPackedVec4Source = (workPerThread, workgroupSize, type = "f32", batchDims, transposeA = false, tileInner = 32, splitK = false, splitedDimInner = 32) => {
        const tileAOuter = workgroupSize[1] * workPerThread[1];
        const tileBOuter = workgroupSize[0] * workPerThread[0];
        const tileAWidth = transposeA ? tileAOuter : tileInner;
        const tileAHight = transposeA ? tileInner : tileAOuter;
        const innerElementSize = tileAWidth / workgroupSize[0];
        const rowPerThreadB = tileInner / workgroupSize[1];
        if (!((transposeA && innerElementSize === 4 && workPerThread[1] === 4 || !transposeA && (innerElementSize === 3 || innerElementSize === 4)) && tileAWidth % workgroupSize[0] === 0 && tileInner % workgroupSize[1] === 0 && workPerThread[0] === 4)) {
          throw new Error(`If transposeA ${transposeA} is true, innerElementSize ${innerElementSize} and workPerThread[1] ${workPerThread[1]} must be 4.
      Otherwise, innerElementSize ${innerElementSize} must be 3 or 4.
  tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${workgroupSize[0]}. tileInner ${tileInner} must be divisible by workgroupSize[1] ${workgroupSize[1]}. colPerThread ${workPerThread[0]} must be 4.`);
        }
        return `
var<workgroup> mm_Asub: array<array<vec${innerElementSize}<${type}>, ${tileAWidth / innerElementSize}>, ${tileAHight}>;
var<workgroup> mm_Bsub: array<array<vec4<${type}>, ${tileBOuter / workPerThread[0]}>, ${tileInner}>;

const rowPerThread = ${workPerThread[1]};
const colPerThread = ${workPerThread[0]};
const innerElementSize = ${innerElementSize};
const tileInner = ${tileInner};

@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]})
fn main(@builtin(local_invocation_id) localId : vec3<u32>,
        @builtin(global_invocation_id) globalId : vec3<u32>,
        @builtin(workgroup_id) workgroupId : vec3<u32>) {
  let localRow = i32(localId.y);
  let tileRow = localRow * rowPerThread;
  let tileCol = i32(localId.x);

  let globalRow =i32(globalId.y) * rowPerThread;
  let globalCol = i32(globalId.x);
  let batch = ${splitK ? "0" : "i32(globalId.z)"};
  ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices("u32(batch)")};` : ""}
  let globalRowStart = i32(workgroupId.y) * ${tileAOuter};

  let num_tiles = ${splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : "(uniforms.dim_inner - 1) / tileInner + 1"};
  var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : "0"};

  var acc: array<vec4<${type}>, rowPerThread>;

  // Loop over shared dimension.
  let tileRowB = localRow * ${rowPerThreadB};
  for (var t = 0; t < num_tiles; t = t + 1) {
      // Load one tile of A into local memory.
      for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {
          let inputRow = tileRow + innerRow;
          let inputCol = tileCol;
          ${writeDataToSubAVec4Snippet(transposeA, batchDims)}
      }

      // Load one tile of B into local memory.
      for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) {
          let inputRow = tileRowB + innerRow;
          let inputCol = tileCol;
          mm_Bsub[inputRow][inputCol] = mm_readB(batch, kStart + inputRow, globalCol${batchDims ? ", batchIndices" : ""});
      }
      kStart = kStart + tileInner;
      workgroupBarrier();

      // Compute acc values for a single thread.
      for (var k = 0; k < tileInner / innerElementSize; k = k + 1) {
          let BCached0 = mm_Bsub[k * innerElementSize][tileCol];
          let BCached1 = mm_Bsub[k * innerElementSize + 1][tileCol];
          let BCached2 = mm_Bsub[k * innerElementSize + 2][tileCol];
          ${innerElementSize === 3 ? "" : "let BCached3 = mm_Bsub[k * innerElementSize + 3][tileCol];"}

          ${calculateResultSnippet(transposeA, innerElementSize)}
      }

      workgroupBarrier();
  }

  for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {
      mm_write(batch, globalRow + innerRow, globalCol, acc[innerRow]);
  }
}`;
      };
      writeDataToSubASnippet = (transpose2, batchDims) => {
        if (transpose2) {
          return `
            mm_Asub[inputRow][inputCol] = mm_readA(batch,
              kStart + inputRow,
              globalRowStart + inputCol${batchDims ? ", batchIndices" : ""});
            `;
        } else {
          return `
            mm_Asub[inputRow][inputCol] = mm_readA(batch,
              globalRowStart + inputRow,
              kStart + inputCol${batchDims ? ", batchIndices" : ""});
            `;
        }
      };
      readDataFromSubASnippet = (transposeA) => transposeA ? "let ACached = mm_Asub[k][tileRow + innerRow];" : "let ACached = mm_Asub[tileRow + innerRow][k];";
      makeMatMulPackedSource = (workPerThread, workgroupSize, type = "f32", batchDims, transposeA = false, tileInner = 32, splitK = false, splitedDimInner = 32, sequentialAccessByThreads = false) => {
        const tileAOuter = workPerThread[1] * workgroupSize[1];
        const tileBOuter = workPerThread[0] * workgroupSize[0];
        const tileAWidth = transposeA ? tileAOuter : tileInner;
        const tileAHight = transposeA ? tileInner : tileAOuter;
        if (!(tileAHight % workgroupSize[1] === 0 && tileAWidth % workgroupSize[0] === 0 && tileInner % workgroupSize[1] === 0)) {
          throw new Error(
            `tileAHight ${tileAHight} must be divisible by workgroupSize[1]${workgroupSize[1]}, tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${workgroupSize[0]}, tileInner ${tileInner} must be divisible by workgroupSize[1]${workgroupSize[1]}`
          );
        }
        const rowPerThreadA = tileAHight / workgroupSize[1];
        const colPerThreadA = tileAWidth / workgroupSize[0];
        const rowPerThreadB = tileInner / workgroupSize[1];
        const matmulSnippet = sequentialAccessByThreads ? `
    let localRow = i32(localId.y);
    let localCol = i32(localId.x);
    let globalRowStart = i32(workgroupId.y) * ${tileAOuter};
    let globalColStart = i32(workgroupId.x) * ${tileBOuter};

    // Loop over shared dimension.
    for (var t = 0; t < num_tiles; t = t + 1) {
      // Load one tile of A into local memory.
      for (var inputRow = localRow; inputRow < ${tileAHight}; inputRow = inputRow + ${workgroupSize[1]}) {
        for (var inputCol = localCol; inputCol < ${tileAWidth}; inputCol = inputCol + ${workgroupSize[0]}) {
          ${writeDataToSubASnippet(transposeA, batchDims)}
        }
      }
      // Load one tile of B into local memory.
      for (var inputRow = localRow; inputRow < ${tileInner}; inputRow = inputRow + ${workgroupSize[1]}) {
            for (var inputCol = localCol; inputCol < ${tileBOuter}; inputCol = inputCol + ${workgroupSize[0]}) {
          mm_Bsub[inputRow][inputCol] = mm_readB(batch,
            kStart + inputRow,
            globalColStart + inputCol${batchDims ? ", batchIndices" : ""});
        }
      }
      kStart = kStart + tileInner;
      workgroupBarrier();

      // Compute acc values for a single thread.
      var BCached : array<${type}, colPerThread>;
      for (var k = 0; k < tileInner; k = k + 1) {
        for (var inner = 0; inner < colPerThread; inner = inner + 1) {
          BCached[inner] = mm_Bsub[k][localCol + inner * ${workgroupSize[0]}];
        }
        for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {
          let ACached = ${transposeA ? `mm_Asub[k][localRow + innerRow * ${workgroupSize[1]}];` : `mm_Asub[localRow + innerRow * ${workgroupSize[1]}][k];`}
          for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {
            acc[innerRow][innerCol] = acc[innerRow][innerCol] +
                ACached * BCached[innerCol];
          }
        }
      }
      workgroupBarrier();
    }
    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {
      let gRow = globalRowStart + localRow + innerRow * ${workgroupSize[1]};
      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {
        let gCol = globalColStart + localCol + innerCol * ${workgroupSize[0]};
        mm_write(batch, gRow, gCol, acc[innerRow][innerCol]);
      }
    }
    ` : `
let tileRow = i32(localId.y) * rowPerThread;
let tileCol = i32(localId.x) * colPerThread;

let globalRow = i32(globalId.y) * rowPerThread;
let globalCol = i32(globalId.x) * colPerThread;
let globalRowStart = i32(workgroupId.y) * ${tileAOuter};

let tileRowA = i32(localId.y) * ${rowPerThreadA};
let tileColA = i32(localId.x) * ${colPerThreadA};
let tileRowB = i32(localId.y) * ${rowPerThreadB};
// Loop over shared dimension.
for (var t = 0; t < num_tiles; t = t + 1) {
  // Load one tile of A into local memory.
  for (var innerRow = 0; innerRow < ${rowPerThreadA}; innerRow = innerRow + 1) {
    for (var innerCol = 0; innerCol < ${colPerThreadA}; innerCol = innerCol + 1) {
      let inputRow = tileRowA + innerRow;
      let inputCol = tileColA + innerCol;
      ${writeDataToSubASnippet(transposeA, batchDims)}
    }
  }

  // Load one tile of B into local memory.
  for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) {
    for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {
      let inputRow = tileRowB + innerRow;
      let inputCol = tileCol + innerCol;
      mm_Bsub[inputRow][inputCol] = mm_readB(batch,
        kStart + inputRow,
        globalCol + innerCol${batchDims ? ", batchIndices" : ""});
    }
  }
  kStart = kStart + tileInner;
  workgroupBarrier();

  // Compute acc values for a single thread.
  var BCached : array<${type}, colPerThread>;
  for (var k = 0; k < tileInner; k = k + 1) {
    for (var inner = 0; inner < colPerThread; inner = inner + 1) {
      BCached[inner] = mm_Bsub[k][tileCol + inner];
    }

    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {
      ${readDataFromSubASnippet(transposeA)}
      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {
        acc[innerRow][innerCol] = acc[innerRow][innerCol] + ACached * BCached[innerCol];
      }
    }
  }

  workgroupBarrier();
}

for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {
  for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {
    mm_write(batch, globalRow + innerRow, globalCol + innerCol,
        acc[innerRow][innerCol]);
  }
}
`;
        return `
  var<workgroup> mm_Asub : array<array<${type}, ${tileAWidth}>, ${tileAHight}>;
  var<workgroup> mm_Bsub : array<array<${type}, ${tileBOuter}>, ${tileInner}>;
  const rowPerThread = ${workPerThread[1]};
  const colPerThread = ${workPerThread[0]};
  const tileInner = ${tileInner};

@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]})
fn main(@builtin(local_invocation_id) localId : vec3<u32>,
        @builtin(global_invocation_id) globalId : vec3<u32>,
        @builtin(workgroup_id) workgroupId : vec3<u32>) {
    let batch = ${splitK ? "0" : "i32(globalId.z)"};
    ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices("u32(batch)")};` : ""}
    let num_tiles = ${splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : "(uniforms.dim_inner - 1) / tileInner + 1"};
    var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : "0"};

    var acc : array<array<${type}, colPerThread>, rowPerThread>;
    ${matmulSnippet}
  }
`;
      };
      matMulReadWriteFnSource = (component, hasBias, applyActivation, variables, isChannelsLast = false) => {
        const [batchVariable, aVariable, bVariable, outputVariable2] = variables;
        const dataType = tensorTypeToWsglStorageType(variables[0].type.tensor);
        const source = `
    fn mm_readA(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${typeSnippet(
          component,
          dataType
        )} {
      var value = ${typeSnippet(component, dataType)}(0.0);
      let col = colIn * ${component};
      if(row < uniforms.dim_a_outer && col < uniforms.dim_inner)
      {
        var aIndices: ${aVariable.type.indices};
        ${convertOutputBatchIndicesToInputBatchIndices(
          "aIndices",
          aVariable,
          aVariable.rank - 2,
          batchVariable.rank,
          "batchIndices"
        )}
        ${aVariable.indicesSet("aIndices", aVariable.rank - 2, "u32(row)")}
        ${aVariable.indicesSet("aIndices", aVariable.rank - 1, "u32(colIn)")}
        value = ${aVariable.getByIndices("aIndices")};
      }
      return value;
    }

    fn mm_readB(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${typeSnippet(
          component,
          dataType
        )} {
      var value = ${typeSnippet(component, dataType)}(0.0);
      let col = colIn * ${component};
      if(row < uniforms.dim_inner && col < uniforms.dim_b_outer)
      {
        var bIndices: ${bVariable.type.indices};
        ${convertOutputBatchIndicesToInputBatchIndices(
          "bIndices",
          bVariable,
          bVariable.rank - 2,
          batchVariable.rank,
          "batchIndices"
        )}
        ${bVariable.indicesSet("bIndices", bVariable.rank - 2, "u32(row)")}
        ${bVariable.indicesSet("bIndices", bVariable.rank - 1, "u32(colIn)")}
        value = ${bVariable.getByIndices("bIndices")};
      }
      return value;
    }

    fn mm_write(batch: i32, row: i32, colIn: i32, valueIn: ${typeSnippet(component, dataType)}) {
      let col = colIn * ${component};
      if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) {
        var value = valueIn;
        let coords = vec3<i32>(batch, row, colIn);
        ${hasBias ? `value = value + ${isChannelsLast ? "bias[colIn]" : `${typeSnippet(component, dataType)}(bias[row])`};` : ""}
        ${applyActivation}
        ${outputVariable2.setByIndices("vec3<u32>(coords)", "value")}
      }
    }
    `;
        return source;
      };
      createMatmulProgramInfo = (inputs, activationAttributes, outputShape, reshapedOutputShape, isChannelsLast = false, squeezeOutputShapeFunction) => {
        const aShape = inputs[0].dims;
        const bShape = inputs[1].dims;
        const outerDimsA = aShape.slice(0, -2);
        const outerDimsB = bShape.slice(0, -2);
        const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2);
        const batchSize = ShapeUtil.size(outerDims);
        const dimAOuter = aShape[aShape.length - 2];
        const dimInner = aShape[aShape.length - 1];
        const dimBOuter = bShape[bShape.length - 1];
        const isVec4 = dimInner % 4 === 0 && dimBOuter % 4 === 0;
        const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];
        const workgroupSize = [8, 8, 1];
        const dispatch = [
          Math.ceil(dimBOuter / workgroupSize[0] / elementsPerThread[0]),
          Math.ceil(dimAOuter / workgroupSize[1] / elementsPerThread[1]),
          Math.ceil(batchSize / workgroupSize[2] / elementsPerThread[2])
        ];
        const components = isVec4 ? 4 : 1;
        const aShapeTemp = [...outerDimsA, dimAOuter, dimInner / components];
        const aRank = aShapeTemp.length;
        const bShapeTemp = [...outerDimsB, dimInner, dimBOuter / components];
        const bRank = bShapeTemp.length;
        const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components];
        const programUniforms = [
          { type: 6 /* int32 */, data: dimAOuter },
          { type: 6 /* int32 */, data: dimBOuter },
          { type: 6 /* int32 */, data: dimInner }
        ];
        appendActivationUniformsData(activationAttributes, programUniforms);
        programUniforms.push(...createTensorShapeVariables(outerDims, aShapeTemp, bShapeTemp));
        const inputDependencies = ["rank", "rank"];
        const hasBias = inputs.length > 2;
        if (hasBias) {
          programUniforms.push(...createTensorShapeVariables(inputs[2].dims));
          inputDependencies.push("rank");
        }
        programUniforms.push(...createTensorShapeVariables(outputShapeTemp));
        const getShaderSource = (shaderHelper) => {
          const batchRank = outerDims.length;
          const batchDims = internalVariable("batchDims", inputs[0].dataType, batchRank, 1);
          const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);
          const A = inputVariable("a", inputs[0].dataType, aRank, components);
          const B = inputVariable("b", inputs[1].dataType, bRank, components);
          const output = outputVariable("result", inputs[0].dataType, outputShapeTemp.length, components);
          const inputVariables = [A, B];
          if (hasBias) {
            const biasComponents = isChannelsLast ? components : 1;
            inputVariables.push(inputVariable("bias", inputs[2].dataType, inputs[2].dims.length, biasComponents));
          }
          const uniforms = [
            { name: "dim_a_outer", type: "i32" },
            { name: "dim_b_outer", type: "i32" },
            { name: "dim_inner", type: "i32" }
          ];
          appendActivationUniforms(activationAttributes, uniforms);
          const baseType = tensorTypeToWsglStorageType(output.type.tensor);
          const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType);
          const declareFunctions = matMulReadWriteFnSource(
            components,
            hasBias,
            applyActivation,
            [batchDims, A, B, output],
            isChannelsLast
          );
          return `
  ${shaderHelper.registerUniforms(uniforms).registerInternalVariables(batchDims).declareVariables(...inputVariables, output)}
  ${declareFunctions}
  ${isVec4 ? makeMatMulPackedVec4Source(elementsPerThread, workgroupSize, dataType, batchDims) : makeMatMulPackedSource(elementsPerThread, workgroupSize, dataType, batchDims)}
                   `;
        };
        return {
          name: "MatMul",
          shaderCache: {
            hint: `${elementsPerThread};${activationAttributes.activation};${isVec4};${isChannelsLast}`,
            inputDependencies
          },
          getRunData: () => ({
            outputs: [
              {
                dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,
                dataType: inputs[0].dataType
              }
            ],
            dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },
            programUniforms
          }),
          getShaderSource
        };
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/3rd-party/conv2d_mm_webgpu.ts
  var conv2dCommonSnippet, createConv2DMatMulProgramInfo;
  var init_conv2d_mm_webgpu = __esm({
    "web/lib/wasm/jsep/webgpu/ops/3rd-party/conv2d_mm_webgpu.ts"() {
      "use strict";
      init_wasm_common();
      init_log();
      init_common();
      init_fuse_utils();
      init_activation_util();
      init_conv_util();
      init_matmul_packed_webgpu();
      conv2dCommonSnippet = (isChannelsLast, fitAOuter, fitBOuter, fitInner, addBias = false, attributes, innerElementSizeX = 4, innerElementSizeW = 4, innerElementSize = 4, dataType = "f32") => {
        const getXSnippet = (innerElementSize2) => {
          switch (innerElementSize2) {
            case 1:
              return "resData = x[xIndex];";
            case 3:
              return `resData = vec3<${dataType}>(x[xIndex], x[xIndex + 1], x[xIndex + 2]);`;
            case 4:
              return "resData = x[xIndex / 4];";
            default:
              throw new Error(`innerElementSize ${innerElementSize2} is not supported.`);
          }
        };
        const getWSnippet = (innerElementSize2) => {
          switch (innerElementSize2) {
            case 1:
              return "return w[row * i32(uniforms.w_shape[3]) + colIn];";
            case 4:
              return "return w[row * i32(uniforms.w_shape[3]) / 4 + colIn];";
            default:
              throw new Error(`innerElementSize ${innerElementSize2} is not supported.`);
          }
        };
        const coordASnippet = isChannelsLast ? `
    let coord = vec4<i32>(batch, xRow, xCol, xCh);
    ` : `
    let coord = vec4<i32>(batch, xCh, xRow, xCol);
    `;
        const coordResSnippet = isChannelsLast ? `
    let coords = vec4<i32>(
      batch,
      row / outWidth,
      row % outWidth,
      col);
    ` : `
    let coords = vec4<i32>(
      batch,
      row,
      col / outWidth,
      col % outWidth);
    `;
        const xHeight = isChannelsLast ? "i32(uniforms.x_shape[1])" : "i32(uniforms.x_shape[2])";
        const xWidth = isChannelsLast ? "i32(uniforms.x_shape[2])" : "i32(uniforms.x_shape[3])";
        const row = isChannelsLast ? "row" : "col";
        const col = isChannelsLast ? "col" : "row";
        const readXSnippet = `
    let inChannels = i32(uniforms.w_shape[2]);
    let outWidth = ${isChannelsLast ? "i32(uniforms.result_shape[2])" : "i32(uniforms.result_shape[3])"};
    let outRow = ${row} / outWidth;
    let outCol = ${row} % outWidth;

    let WRow = ${col} / (i32(uniforms.w_shape[1]) * inChannels);
    let WCol = ${col} / inChannels % i32(uniforms.w_shape[1]);
    let xRow = outRow * uniforms.stride[0] + uniforms.dilation[0] * WRow - uniforms.pad[0];
    let xCol = outCol * uniforms.stride[1] + uniforms.dilation[1] * WCol - uniforms.pad[1];
    let xCh = ${col} % inChannels;
    var resData = ${typeSnippet(innerElementSizeX, dataType)}(0.0);
    // The bounds checking is always needed since we use it to pad zero for
    // the 'same' padding type.
    if (xRow >= 0 && xRow < ${xHeight} && xCol >= 0 && xCol < ${xWidth}) {
      ${coordASnippet}
      let xIndex = getIndexFromCoords4D(coord, vec4<i32>(uniforms.x_shape));
      ${getXSnippet(innerElementSizeX)}
    }
    return resData;`;
        const sampleX = isChannelsLast ? fitAOuter && fitInner ? `
    let col = colIn * ${innerElementSizeX};
    ${readXSnippet}` : `
    let col = colIn * ${innerElementSizeX};
    if (row < uniforms.dim_a_outer && col < uniforms.dim_inner) {
      ${readXSnippet}
    }
    return ${typeSnippet(innerElementSizeX, dataType)}(0.0);` : fitInner && fitBOuter ? `
    let col = colIn * ${innerElementSizeX};
    ${readXSnippet}` : `
    let col = colIn * ${innerElementSizeX};
    if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) {
      ${readXSnippet}
    }
    return ${typeSnippet(innerElementSizeX, dataType)}(0.0);`;
        const sampleW = isChannelsLast ? fitInner && fitBOuter ? getWSnippet(innerElementSizeW) : `
    let col = colIn * ${innerElementSizeW};
    if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) {
      ${getWSnippet(innerElementSizeW)}
    }
    return ${typeSnippet(innerElementSizeW, dataType)}(0.0);` : `
    let col = colIn * ${innerElementSizeW};
    if (row < uniforms.dim_inner && col < uniforms.dim_a_outer) {
      ${getWSnippet(innerElementSizeW)}
    }
    return ${typeSnippet(innerElementSizeW, dataType)}(0.0);`;
        const resType = typeSnippet(innerElementSize, dataType);
        const aType = isChannelsLast ? typeSnippet(innerElementSizeX, dataType) : typeSnippet(innerElementSizeW, dataType);
        const bType = isChannelsLast ? typeSnippet(innerElementSizeW, dataType) : typeSnippet(innerElementSizeX, dataType);
        const applyActivation = getActivationSnippet(attributes, resType, dataType);
        const userCode = `
    fn mm_readA(batch: i32, row : i32, colIn : i32) -> ${aType} {
      ${isChannelsLast ? sampleX : sampleW}
    }

    fn mm_readB(batch: i32, row : i32, colIn : i32) -> ${bType} {
      ${isChannelsLast ? sampleW : sampleX}
    }

    fn mm_write(batch: i32, row : i32, colIn : i32, valueIn : ${resType}) {
      let col = colIn * ${innerElementSize};
      if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer)
      {
      var value = valueIn;
      let outWidth = ${isChannelsLast ? "i32(uniforms.result_shape[2])" : "i32(uniforms.result_shape[3])"};
      ${coordResSnippet}
      ${biasSnippet(addBias)}
      ${applyActivation}
      setOutputAtCoords(coords[0], coords[1], coords[2], coords[3], value);
      }
    }`;
        return userCode;
      };
      createConv2DMatMulProgramInfo = (inputs, attributes, outputShape, dimAOuter, dimBOuter, dimInner, hasBias, sequentialAccessByThreads, squeezeOutputShapeFunction) => {
        const isChannelsLast = attributes.format === "NHWC";
        const inChannels = isChannelsLast ? inputs[0].dims[3] : inputs[0].dims[1];
        const batchSize = outputShape[0];
        const outWidth = isChannelsLast ? outputShape[2] : outputShape[3];
        const outHeight = isChannelsLast ? outputShape[1] : outputShape[2];
        const outChannels = isChannelsLast ? outputShape[3] : outputShape[1];
        const isVec4 = isChannelsLast && (inChannels % 4 === 0 || inChannels % 3 === 0) && outChannels % 4 === 0;
        const dispatchX = isChannelsLast ? outChannels : outWidth * outHeight;
        const dispatchY = isChannelsLast ? outWidth * outHeight : outChannels;
        const workGroupSize = [8, 8, 1];
        const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];
        const dispatch = [
          Math.ceil(dispatchX / workGroupSize[0] / elementsPerThread[0]),
          Math.ceil(dispatchY / workGroupSize[1] / elementsPerThread[1]),
          Math.ceil(batchSize / workGroupSize[2] / elementsPerThread[2])
        ];
        LOG_DEBUG("verbose", () => `[conv2d_mm_webgpu] dispatch = ${dispatch}`);
        const innerElementSize = isVec4 ? isChannelsLast && inChannels % 4 !== 0 ? 3 : 4 : 1;
        const tileAOuter = workGroupSize[1] * elementsPerThread[1];
        const tileBOuter = workGroupSize[0] * elementsPerThread[0];
        const tileInner = Math.max(workGroupSize[0] * innerElementSize, workGroupSize[1]);
        const fitAOuter = dimAOuter % tileAOuter === 0;
        const fitBOuter = dimBOuter % tileBOuter === 0;
        const fitInner = dimInner % tileInner === 0;
        const elementsSize = isVec4 ? [innerElementSize, 4, 4] : [1, 1, 1];
        const programUniforms = [
          { type: 6 /* int32 */, data: dimAOuter },
          { type: 6 /* int32 */, data: dimBOuter },
          { type: 6 /* int32 */, data: dimInner },
          { type: 6 /* int32 */, data: [attributes.pads[0], attributes.pads[1]] },
          { type: 6 /* int32 */, data: attributes.strides },
          { type: 6 /* int32 */, data: attributes.dilations }
        ];
        appendActivationUniformsData(attributes, programUniforms);
        programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims));
        const inputDependencies = ["rank", "rank"];
        if (hasBias) {
          programUniforms.push(...createTensorShapeVariables(inputs[2].dims));
          inputDependencies.push("rank");
        }
        programUniforms.push(...createTensorShapeVariables(outputShape));
        const getShaderSource = (shaderHelper) => {
          const uniforms = [
            { name: "dim_a_outer", type: "i32" },
            { name: "dim_b_outer", type: "i32" },
            { name: "dim_inner", type: "i32" },
            { name: "pad", type: "i32", length: 2 },
            { name: "stride", type: "i32", length: 2 },
            { name: "dilation", type: "i32", length: 2 }
          ];
          appendActivationUniforms(attributes, uniforms);
          const components = isVec4 ? 4 : 1;
          const t = tensorTypeToWsglStorageType(inputs[0].dataType);
          let declareFunctions = `
      fn setOutputAtIndex(flatIndex : i32, value : ${isVec4 ? `vec4<${t}>` : t}) {
        result[flatIndex] = ${isVec4 ? `vec4<${t}>` : t}(value);
      }
      fn setOutputAtCoords(d0 : i32, d1 : i32, d2 : i32, d3 : i32, value : ${isVec4 ? `vec4<${t}>` : t}) {
        let flatIndex = getOutputIndexFromCoords(vec4<i32>(d0, d1, d2, d3));
        setOutputAtIndex(flatIndex ${isVec4 ? "/ 4" : ""}, value);
      }`;
          const x = inputVariable(
            "x",
            inputs[0].dataType,
            inputs[0].dims.length,
            innerElementSize === 3 ? 1 : innerElementSize
          );
          const w = inputVariable("w", inputs[1].dataType, inputs[1].dims.length, components);
          const inputVariables = [x, w];
          const output = outputVariable("result", inputs[0].dataType, outputShape.length, components);
          if (hasBias) {
            const bias = inputVariable("bias", inputs[2].dataType, inputs[2].dims.length, components);
            inputVariables.push(bias);
            declareFunctions += `
        fn getBiasByOutputCoords(coords : vec4<i32>) -> ${isVec4 ? `vec4<${t}>` : t} {
          return bias[coords.${isChannelsLast ? "w" : "y"}${isVec4 ? "/ 4" : ""}];
        }`;
          }
          return `
        ${utilFunctions("uniforms.result_strides")}
        //struct Uniforms { xShape : vec4<i32>, wShape : vec4<i32>, outShape : vec4<i32>,
        //  outShapeStrides: vec3<i32>, filterDims : vec2<i32>, pad : vec2<i32>, stride : vec2<i32>,
        //  dilation : vec2<i32>, dimAOuter : i32, dimBOuter : i32, dimInner : i32 };
        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}
        ${declareFunctions}
        ${conv2dCommonSnippet(
            isChannelsLast,
            fitAOuter,
            fitBOuter,
            fitInner,
            hasBias,
            attributes,
            elementsSize[0],
            elementsSize[1],
            elementsSize[2],
            t
          )}
        ${isVec4 ? makeMatMulPackedVec4Source(elementsPerThread, workGroupSize, t, void 0, !isChannelsLast, tileInner) : makeMatMulPackedSource(
            elementsPerThread,
            workGroupSize,
            t,
            void 0,
            !isChannelsLast,
            tileInner,
            false,
            void 0,
            sequentialAccessByThreads
          )}`;
        };
        return {
          name: "Conv2DMatMul",
          shaderCache: {
            hint: `${attributes.cacheKey};${innerElementSize};${isVec4};${fitAOuter};${fitBOuter};${fitInner};${tileAOuter};${tileBOuter};${tileInner}`,
            inputDependencies
          },
          getRunData: () => ({
            outputs: [
              {
                dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,
                dataType: inputs[0].dataType
              }
            ],
            dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },
            programUniforms
          }),
          getShaderSource
        };
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/3rd-party/conv3d_naive_webgpu.ts
  var arrayProduct, parse3TupleParam, getEffectiveFilterSize, computeDefaultPad, computeOutputShape4D, get3DPadAndOutInfo, computeConv3DInfo, createConv3DNaiveProgramInfo;
  var init_conv3d_naive_webgpu = __esm({
    "web/lib/wasm/jsep/webgpu/ops/3rd-party/conv3d_naive_webgpu.ts"() {
      "use strict";
      init_wasm_common();
      init_log();
      init_util();
      init_common();
      init_fuse_utils();
      init_activation_util();
      arrayProduct = (arr) => {
        let product = 1;
        for (let i = 0; i < arr.length; i++) {
          product *= arr[i];
        }
        return product;
      };
      parse3TupleParam = (param) => typeof param === "number" ? [param, param, param] : param;
      getEffectiveFilterSize = (filterSize, dilation) => {
        if (dilation <= 1) {
          return filterSize;
        }
        return filterSize + (filterSize - 1) * (dilation - 1);
      };
      computeDefaultPad = (inputShape, fieldSize, stride, dilation = 1) => {
        const effectiveFieldSize = getEffectiveFilterSize(fieldSize, dilation);
        return Math.floor((inputShape[0] * (stride - 1) - stride + effectiveFieldSize) / 2);
      };
      computeOutputShape4D = (inShape, filterShape, outChannels, strides, zeroPad) => {
        if (zeroPad == null) {
          zeroPad = computeDefaultPad(inShape, filterShape[0], strides[0]);
        }
        const outShape = [0, 0, 0, outChannels];
        for (let index = 0; index < 3; index++) {
          if (inShape[index] + 2 * zeroPad >= filterShape[index]) {
            outShape[index] = Math.trunc((inShape[index] - filterShape[index] + 2 * zeroPad) / strides[index] + 1);
          }
        }
        return outShape;
      };
      get3DPadAndOutInfo = (pad2, inDepth, inHeight, inWidth, strideDepth, strideHeight, strideWidth, filterDepth, filterHeight, filterWidth) => {
        let padInfo;
        let outDepth;
        let outHeight;
        let outWidth;
        if (pad2 === "VALID") {
          pad2 = 0;
        }
        if (typeof pad2 === "number") {
          padInfo = { top: pad2, bottom: pad2, left: pad2, right: pad2, front: pad2, back: pad2 };
          const outShape = computeOutputShape4D(
            [inDepth, inHeight, inWidth, 1],
            [filterDepth, filterHeight, filterWidth],
            1,
            [strideDepth, strideHeight, strideWidth],
            pad2
          );
          outDepth = outShape[0];
          outHeight = outShape[1];
          outWidth = outShape[2];
        } else if (Array.isArray(pad2)) {
          if (!pad2.every((val, _, arr) => val === arr[0])) {
            throw Error(`Unsupported padding parameter: ${pad2}`);
          }
          padInfo = { top: pad2[0], bottom: pad2[1], left: pad2[2], right: pad2[3], front: pad2[4], back: pad2[5] };
          const outShape = computeOutputShape4D(
            [inDepth, inHeight, inWidth, 1],
            [filterDepth, filterHeight, filterWidth],
            1,
            [strideDepth, strideHeight, strideWidth],
            pad2[0]
          );
          outDepth = outShape[0];
          outHeight = outShape[1];
          outWidth = outShape[2];
        } else if (pad2 === "SAME_UPPER") {
          outDepth = Math.ceil(inDepth / strideDepth);
          outHeight = Math.ceil(inHeight / strideHeight);
          outWidth = Math.ceil(inWidth / strideWidth);
          const padAlongDepth = (outDepth - 1) * strideDepth + filterDepth - inDepth;
          const padAlongHeight = (outHeight - 1) * strideHeight + filterHeight - inHeight;
          const padAlongWidth = (outWidth - 1) * strideWidth + filterWidth - inWidth;
          const front = Math.floor(padAlongDepth / 2);
          const back = padAlongDepth - front;
          const top = Math.floor(padAlongHeight / 2);
          const bottom = padAlongHeight - top;
          const left = Math.floor(padAlongWidth / 2);
          const right = padAlongWidth - left;
          padInfo = { top, bottom, left, right, front, back };
        } else {
          throw Error(`Unknown padding parameter: ${pad2}`);
        }
        return { padInfo, outDepth, outHeight, outWidth };
      };
      computeConv3DInfo = (inShape, filterShape, strides, dilations, pad2, depthwise = false, dataFormat = "channelsLast") => {
        let batchSize, inDepth, inHeight, inWidth, inChannels;
        if (dataFormat === "channelsLast") {
          [batchSize, inDepth, inHeight, inWidth, inChannels] = inShape;
        } else if (dataFormat === "channelsFirst") {
          [batchSize, inChannels, inDepth, inHeight, inWidth] = inShape;
        } else {
          throw new Error(`Unknown dataFormat ${dataFormat}`);
        }
        const [filterChannels, , filterDepth, filterHeight, filterWidth] = filterShape;
        const [strideDepth, strideHeight, strideWidth] = parse3TupleParam(strides);
        const [dilationDepth, dilationHeight, dilationWidth] = parse3TupleParam(dilations);
        const effectiveFilterDepth = getEffectiveFilterSize(filterDepth, dilationDepth);
        const effectiveFilterHeight = getEffectiveFilterSize(filterHeight, dilationHeight);
        const effectiveFilterWidth = getEffectiveFilterSize(filterWidth, dilationWidth);
        const { padInfo, outDepth, outHeight, outWidth } = get3DPadAndOutInfo(
          pad2,
          inDepth,
          inHeight,
          inWidth,
          strideDepth,
          strideHeight,
          strideWidth,
          effectiveFilterDepth,
          effectiveFilterHeight,
          effectiveFilterWidth
        );
        const outChannels = depthwise ? filterChannels * inChannels : filterChannels;
        let outShape = [0, 0, 0, 0, 0];
        if (dataFormat === "channelsFirst") {
          outShape = [batchSize, outChannels, outDepth, outHeight, outWidth];
        } else if (dataFormat === "channelsLast") {
          outShape = [batchSize, outDepth, outHeight, outWidth, outChannels];
        }
        return {
          batchSize,
          dataFormat,
          inDepth,
          inHeight,
          inWidth,
          inChannels,
          outDepth,
          outHeight,
          outWidth,
          outChannels,
          padInfo,
          strideDepth,
          strideHeight,
          strideWidth,
          filterDepth,
          filterHeight,
          filterWidth,
          effectiveFilterDepth,
          effectiveFilterHeight,
          effectiveFilterWidth,
          dilationDepth,
          dilationHeight,
          dilationWidth,
          inShape,
          outShape,
          filterShape
        };
      };
      createConv3DNaiveProgramInfo = (inputs, attributes, outputShape, filterDims, pads, dataFormat) => {
        const isChannelLast = dataFormat === "channelsLast";
        const inChannels = isChannelLast ? inputs[0].dims[3] : inputs[0].dims[1];
        const isVec4 = false;
        const workGroupSize = [64, 1, 1];
        const dispatchLayout = { x: outputShape.map((_, i) => i) };
        const dispatch = [Math.ceil(arrayProduct(dispatchLayout.x.map((d) => outputShape[d])) / workGroupSize[0]), 1, 1];
        LOG_DEBUG("verbose", () => `[conv3d_naive_webgpu] dispatch = ${dispatch}`);
        const innerElementSize = isVec4 ? isChannelLast && inChannels % 4 !== 0 ? 3 : 4 : 1;
        const outputSize = ShapeUtil.size(outputShape);
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 12 /* uint32 */, data: filterDims },
          { type: 12 /* uint32 */, data: pads },
          { type: 12 /* uint32 */, data: attributes.strides },
          { type: 12 /* uint32 */, data: attributes.dilations }
        ];
        appendActivationUniformsData(attributes, programUniforms);
        programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims));
        const inputDependencies = ["rank", "rank"];
        const hasBias = inputs.length === 3;
        if (hasBias) {
          programUniforms.push(...createTensorShapeVariables(inputs[2].dims));
          inputDependencies.push("rank");
        }
        programUniforms.push(...createTensorShapeVariables(outputShape));
        const getShaderSource = (shaderHelper) => {
          const uniforms = [
            { name: "output_size", type: "u32" },
            { name: "filter_dims", type: "u32", length: filterDims.length },
            { name: "pads", type: "u32", length: pads.length },
            { name: "strides", type: "u32", length: attributes.strides.length },
            { name: "dilations", type: "u32", length: attributes.dilations.length }
          ];
          appendActivationUniforms(attributes, uniforms);
          const components = isVec4 ? 4 : 1;
          const t = tensorTypeToWsglStorageType(inputs[0].dataType);
          const x = inputVariable(
            "x",
            inputs[0].dataType,
            inputs[0].dims.length,
            innerElementSize === 3 ? 1 : innerElementSize
          );
          const w = inputVariable("W", inputs[1].dataType, inputs[1].dims.length, components);
          const inputVariables = [x, w];
          const output = outputVariable("result", inputs[0].dataType, outputShape.length, components);
          let declareFunctions = "";
          if (hasBias) {
            const bias = inputVariable("bias", inputs[2].dataType, inputs[2].dims.length, components);
            inputVariables.push(bias);
            declareFunctions += `
        fn getBiasByOutputCoords(coords : array<u32, 5>) -> ${isVec4 ? `vec4<${t}>` : t} {
          return bias[${isChannelLast ? getElementAt("coords", 4, 5) : getElementAt("coords", 1, 5)}${isVec4 ? "/ 4" : ""}];
        }`;
          }
          const resType = typeSnippet(innerElementSize, t);
          const applyActivation = getActivationSnippet(attributes, resType, t);
          return `
            ${declareFunctions}
            fn getX(d0 : u32, d1 : u32, d2 : u32, d3 : u32, d4 : u32) -> f32 {
              let aIndices = array<u32, 5>(d0, d1, d2, d3, d4);
              return ${x.getByIndices("aIndices")};
            }
            fn getW(d0 : u32, d1 : u32, d2 : u32, d3 : u32, d4 : u32) -> f32 {
              let aIndices = array<u32, 5>(d0, d1, d2, d3, d4);
              return ${w.getByIndices("aIndices")};
            }
          ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}
          ${shaderHelper.mainStart()}
          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
              let coords = ${output.offsetToIndices("global_idx")};
              let batch = ${getElementAt("coords", 0, x.rank)};
              let d2 = ${isChannelLast ? getElementAt("coords", x.rank - 1, x.rank) : getElementAt("coords", 1, x.rank)};
              let xFRCCorner = vec3<u32>(${isChannelLast ? getElementAt("coords", 1, x.rank) : getElementAt("coords", 2, x.rank)},
              ${isChannelLast ? getElementAt("coords", 2, x.rank) : getElementAt("coords", 3, x.rank)},
              ${isChannelLast ? getElementAt("coords", 3, x.rank) : getElementAt("coords", 4, x.rank)}) * uniforms.strides - uniforms.pads;
              let xFCorner = xFRCCorner.x;
              let xRCorner = xFRCCorner.y;
              let xCCorner = xFRCCorner.z;
              let xShapeY = ${isChannelLast ? getElementAt("uniforms.x_shape", 1, x.rank) : getElementAt("uniforms.x_shape", 2, x.rank)};
              let xShapeZ = ${isChannelLast ? getElementAt("uniforms.x_shape", 2, x.rank) : getElementAt("uniforms.x_shape", 3, x.rank)};
              let xShapeW = ${isChannelLast ? getElementAt("uniforms.x_shape", 3, x.rank) : getElementAt("uniforms.x_shape", 4, x.rank)};
              let xShapeU = ${isChannelLast ? getElementAt("uniforms.x_shape", 4, x.rank) : getElementAt("uniforms.x_shape", 1, x.rank)};
              let inputDepthNearestVec4 = (xShapeU / 4) * 4;
              let inputDepthVec4Remainder = xShapeU % 4;

              var value = 0.0;
              for (var wF = 0u; wF < uniforms.filter_dims[0]; wF++) {
                let xF = xFCorner + wF * uniforms.dilations[0];
                if (xF < 0 || xF >= xShapeY) {
                  continue;
                }

                for (var wR = 0u; wR < uniforms.filter_dims[1]; wR++) {
                  let xR = xRCorner + wR * uniforms.dilations[1];
                  if (xR < 0 || xR >= xShapeZ) {
                    continue;
                  }

                  for (var wC = 0u; wC < uniforms.filter_dims[2]; wC++) {
                    let xC = xCCorner + wC * uniforms.dilations[2];
                    if (xC < 0 || xC >= xShapeW) {
                      continue;
                    }

                    for (var d1 = 0u; d1 < inputDepthNearestVec4; d1 += 4) {
                      ${isChannelLast ? `let xValues = vec4<f32>(
                               getX(batch, xF, xR, xC, d1),
                               getX(batch, xF, xR, xC, d1 + 1),
                               getX(batch, xF, xR, xC, d1 + 2),
                               getX(batch, xF, xR, xC, d1 + 3));
                            ` : `let xValues = vec4<f32>(
                               getX(batch, d1, xF, xR, xC),
                               getX(batch, d1 + 1, xF, xR, xC),
                               getX(batch, d1 + 2, xF, xR, xC),
                               getX(batch, d1 + 3, xF, xR, xC));
                            `}
                            let wValues = vec4<f32>(
                              getW(d2, d1, wF, wR, wC),
                              getW(d2, d1 + 1, wF, wR, wC),
                              getW(d2, d1 + 2, wF, wR, wC),
                              getW(d2, d1 + 3, wF, wR, wC));
                      value += dot(xValues, wValues);
                    }
                    if (inputDepthVec4Remainder == 1) {
                        ${isChannelLast ? `value += getX(batch, xF, xR, xC, inputDepthNearestVec4)
                          * getW(d2, inputDepthNearestVec4, wF, wR, wC);` : `value += getX(batch, inputDepthNearestVec4, xF, xR, xC)
                          * getW(d2, inputDepthNearestVec4, wF, wR, wC);`}
                    } else if (inputDepthVec4Remainder == 2) {
                      ${isChannelLast ? `let xValues = vec2<f32>(
                        getX(batch, xF, xR, xC, inputDepthNearestVec4),
                        getX(batch, xF, xR, xC, inputDepthNearestVec4 + 1));
                      ` : `let xValues = vec2<f32>(
                        getX(batch, inputDepthNearestVec4, xF, xR, xC),
                        getX(batch, inputDepthNearestVec4 + 1, xF, xR, xC));
                    `}
                    let wValues = vec2<f32>(
                      getW(d2, inputDepthNearestVec4, wF, wR, wC),
                      getW(d2, inputDepthNearestVec4 + 1, wF, wR, wC));
                      value += dot(xValues, wValues);
                    } else if (inputDepthVec4Remainder == 3) {
                      ${isChannelLast ? `let xValues = vec3<f32>(
                        getX(batch, xF, xR, xC, inputDepthNearestVec4),
                        getX(batch, xF, xR, xC, inputDepthNearestVec4 + 1),
                        getX(batch, xF, xR, xC, inputDepthNearestVec4 + 2));
                      ` : `let xValues = vec3<f32>(
                        getX(batch, inputDepthNearestVec4, xF, xR, xC),
                        getX(batch, inputDepthNearestVec4 + 1, xF, xR, xC),
                        getX(batch, inputDepthNearestVec4 + 2, xF, xR, xC));
                    `}
                    let wValues = vec3<f32>(
                      getW(d2, inputDepthNearestVec4, wF, wR, wC),
                      getW(d2, inputDepthNearestVec4 + 1, wF, wR, wC),
                      getW(d2, inputDepthNearestVec4 + 2, wF, wR, wC));
                      value += dot(xValues, wValues);
                    }
                  }
                }
              }
              ${hasBias ? "value = value + getBiasByOutputCoords(coords)" : ""};
              ${applyActivation}
              result[global_idx] = f32(value);
          }`;
        };
        return {
          name: "Conv3DNaive",
          shaderCache: { hint: `${attributes.cacheKey};${isChannelLast};${innerElementSize};${hasBias}`, inputDependencies },
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],
            dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },
            programUniforms
          }),
          getShaderSource
        };
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/conv-grouped.ts
  var createGroupedConvProgramInfo, createGroupedConvVectorizeProgramInfo;
  var init_conv_grouped = __esm({
    "web/lib/wasm/jsep/webgpu/ops/conv-grouped.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_common();
      init_fuse_utils();
      createGroupedConvProgramInfo = (inputs, attributes, outputShape, squeezeOutputShapeFunction) => {
        const hasBias = inputs.length > 2;
        const processBias = hasBias ? "value += b[output_channel];" : "";
        const xShape = inputs[0].dims;
        const wShape = inputs[1].dims;
        const isChannelLast = attributes.format === "NHWC";
        const outputChannels = isChannelLast ? outputShape[3] : outputShape[1];
        const outputChannelsPerGroup = outputChannels / attributes.group;
        const components = isChannelLast && outputChannelsPerGroup >= 4 ? getMaxComponents(outputChannels) : 1;
        const outputSize = ShapeUtil.size(outputShape) / components;
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 12 /* uint32 */, data: attributes.dilations },
          { type: 12 /* uint32 */, data: [attributes.strides[0], attributes.strides[1]] },
          { type: 12 /* uint32 */, data: [attributes.pads[0], attributes.pads[1]] },
          { type: 12 /* uint32 */, data: outputChannelsPerGroup }
        ];
        appendActivationUniformsData(attributes, programUniforms);
        programUniforms.push(
          ...createTensorShapeVariables(xShape, [wShape[0], wShape[1], wShape[2], wShape[3] / components])
        );
        const inputDependencies = hasBias ? ["rank", "rank", "rank"] : ["rank", "rank"];
        programUniforms.push(
          ...createTensorShapeVariables([outputShape[0], outputShape[1], outputShape[2], outputShape[3] / components])
        );
        const getShaderSource = (shaderHelper) => {
          const output = outputVariable("output", inputs[0].dataType, outputShape.length, components);
          const baseType = tensorTypeToWsglStorageType(output.type.tensor);
          const applyActivation = getActivationSnippet(attributes, output.type.value, baseType);
          const x = inputVariable("x", inputs[0].dataType, xShape.length);
          const w = inputVariable("w", inputs[1].dataType, wShape.length, components);
          const inputVars = [x, w];
          if (hasBias) {
            inputVars.push(inputVariable("b", inputs[2].dataType, inputs[2].dims, components));
          }
          const uniforms = [
            { name: "output_size", type: "u32" },
            { name: "dilations", type: "u32", length: attributes.dilations.length },
            { name: "strides", type: "u32", length: 2 },
            { name: "pads", type: "u32", length: 2 },
            { name: "output_channels_per_group", type: "u32" }
          ];
          appendActivationUniforms(attributes, uniforms);
          const calculateResult = isChannelLast ? `
      for (var wHeight: u32 = 0u; wHeight < uniforms.w_shape[0]; wHeight++) {
        let xHeight = xRCCorner.x + wHeight * uniforms.dilations[0];

        if (xHeight < 0u || xHeight >= uniforms.x_shape[1]) {
          continue;
        }

        for (var wWidth: u32 = 0u; wWidth < uniforms.w_shape[1]; wWidth++) {
          let xWidth = xRCCorner.y + wWidth * uniforms.dilations[1];
          if (xWidth < 0u || xWidth >= uniforms.x_shape[2]) {
            continue;
          }

          for (var wInChannel: u32 = 0u; wInChannel < uniforms.w_shape[2]; wInChannel++) {
            let input_channel = in_channel_offset + wInChannel;
            let xVal = ${x.get("batch", "xHeight", "xWidth", "input_channel")};
            let wVal = ${w.get("wHeight", "wWidth", "wInChannel", "output_channel")};
            value += xVal * wVal;
          }
        }
      }
      ` : `
      for (var wInChannel: u32 = 0u; wInChannel < uniforms.w_shape[1]; wInChannel++) {
        let input_channel = in_channel_offset + wInChannel;
        for (var wHeight: u32 = 0u; wHeight < uniforms.w_shape[2]; wHeight++) {
          let xHeight = xRCCorner.x + wHeight * uniforms.dilations[0];

          if (xHeight < 0u || xHeight >= uniforms.x_shape[2]) {
            continue;
          }

          for (var wWidth: u32 = 0u; wWidth < uniforms.w_shape[3]; wWidth++) {
            let xWidth = xRCCorner.y + wWidth * uniforms.dilations[1];
            if (xWidth < 0u || xWidth >= uniforms.x_shape[3]) {
              continue;
            }

            let xVal = ${x.get("batch", "input_channel", "xHeight", "xWidth")};
            let wVal = ${w.get("output_channel", "wInChannel", "wHeight", "wWidth")};
            value += xVal * wVal;
          }
        }
      }
      `;
          return `
  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}

  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}

    let outputIndices = ${output.offsetToIndices("global_idx")};
    let batch: u32 = outputIndices[0];
    let output_channel: u32 = outputIndices[${isChannelLast ? 3 : 1}];
    let xRCCorner: vec2<u32> = vec2<u32>(outputIndices[${isChannelLast ? 1 : 2}], outputIndices[${isChannelLast ? 2 : 3}]) * uniforms.strides - uniforms.pads;
    let group_id: u32 = output_channel * ${components} / uniforms.output_channels_per_group;
    var in_channel_offset = group_id * uniforms.w_shape[${isChannelLast ? 2 : 1}];

    var value: ${output.type.value} = ${output.type.value}(0);
    ${calculateResult}
    ${processBias}
    ${applyActivation}
    ${output.setByOffset("global_idx", "value")}
  }`;
        };
        return {
          name: "GroupedConv",
          shaderCache: { hint: `${attributes.cacheKey}_${components}`, inputDependencies },
          getRunData: () => ({
            outputs: [
              {
                dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,
                dataType: inputs[0].dataType
              }
            ],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms
          }),
          getShaderSource
        };
      };
      createGroupedConvVectorizeProgramInfo = (inputs, attributes, outputShape, squeezeOutputShapeFunction) => {
        const hasBias = inputs.length > 2;
        const components = getMaxComponents(outputShape[3]);
        const outputNumber = getMaxComponents(outputShape[2]);
        const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;
        const xShape = [inputs[0].dims[0], inputs[0].dims[1], inputs[0].dims[2], inputs[0].dims[3] / components];
        const wShape = [inputs[1].dims[0], inputs[1].dims[1], inputs[1].dims[2], inputs[1].dims[3] / components];
        const outputShapeInShader = [outputShape[0], outputShape[1], outputShape[2], outputShape[3] / components];
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 6 /* int32 */, data: [attributes.strides[0], attributes.strides[1]] },
          { type: 6 /* int32 */, data: [attributes.pads[0], attributes.pads[1]] }
        ];
        appendActivationUniformsData(attributes, programUniforms);
        programUniforms.push(...createTensorShapeVariables(xShape, wShape, outputShapeInShader));
        const xNumber = (outputNumber - 1) * attributes.strides[1] + wShape[1];
        const getShaderSource = (shaderHelper) => {
          const output = outputVariable("output", inputs[0].dataType, outputShapeInShader.length, components);
          const baseType = tensorTypeToWsglStorageType(output.type.tensor);
          const applyActivation = getActivationSnippet(attributes, output.type.value, baseType);
          const x = inputVariable("x", inputs[0].dataType, xShape.length, components);
          const w = inputVariable("w", inputs[1].dataType, wShape.length, components);
          const inputVars = [x, w];
          if (hasBias) {
            inputVars.push(inputVariable("b", inputs[2].dataType, inputs[2].dims, components));
          }
          const processBias = hasBias ? "value += b[output_channel];" : "";
          const uniforms = [
            { name: "output_size", type: "u32" },
            { name: "strides", type: "i32", length: 2 },
            { name: "pads", type: "i32", length: 2 }
          ];
          appendActivationUniforms(attributes, uniforms);
          return `
  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}
  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
    let width0 = uniforms.output_shape[3];
    let output_channel = global_idx % width0;
    var index1 = global_idx / width0;
    let width1 = uniforms.output_shape[2] / ${outputNumber}u;
    let col = (index1 % width1) * ${outputNumber}u;
    index1 = index1 / width1;
    let row = index1 % uniforms.output_shape[1];
    let batch = index1 / uniforms.output_shape[1];

    let x_corner = vec2<i32>(i32(row), i32(col)) * uniforms.strides - uniforms.pads;

    var x_vals: array<${x.type.value}, ${xNumber}>;
    var values: array<${output.type.value}, ${outputNumber}>;
    let input_channel = output_channel;
    // Use constant instead of uniform can give better performance for w's height/width.
    for (var w_height: u32 = 0u; w_height < ${wShape[0]}; w_height++) {
      let x_height = x_corner.x + i32(w_height);
      if (x_height >= 0 && u32(x_height) < uniforms.x_shape[1]) {
        for (var i = 0; i < ${xNumber}; i++) {
          let x_width = x_corner.y + i;
          if (x_width >= 0 && u32(x_width) < uniforms.x_shape[2]) {
            x_vals[i] = ${x.get("batch", "u32(x_height)", "u32(x_width)", "input_channel")};
          } else {
            x_vals[i] = ${x.type.value}(0);
          }
        }
        for (var w_width: u32 = 0u; w_width < ${wShape[1]}; w_width++) {
          let w_val = ${w.get("w_height", "w_width", "0", "output_channel")};
          for (var i = 0u; i < ${outputNumber}u; i++) {
            values[i] = fma(x_vals[i * u32(uniforms.strides[1]) + w_width], w_val, values[i]);
          }
        }
      }
    }

    for (var i = 0u; i < ${outputNumber}u; i++) {
      var value = values[i];
      ${processBias}
      ${applyActivation}
      ${output.set("batch", "row", "col + i", "output_channel", "value")};
    }
  }`;
        };
        return {
          name: "GroupedConv-Vectorize",
          shaderCache: {
            hint: `${attributes.cacheKey};${components};${outputNumber};${xNumber};${wShape[0]};${wShape[1]}`,
            inputDependencies: hasBias ? ["rank", "rank", "type"] : ["rank", "rank"]
          },
          getRunData: () => ({
            outputs: [
              {
                dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,
                dataType: inputs[0].dataType
              }
            ],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms
          }),
          getShaderSource
        };
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/conv.ts
  var calculateOutputShape, weightTransposeAttribute, validateInputs8, getAdjustedConvAttributes, parseConvAttributes, conv2d, conv1d, conv3d, conv;
  var init_conv = __esm({
    "web/lib/wasm/jsep/webgpu/ops/conv.ts"() {
      "use strict";
      init_util();
      init_conv2d_mm_webgpu();
      init_conv3d_naive_webgpu();
      init_matmul_packed_webgpu();
      init_conv_grouped();
      init_fuse_utils();
      init_matmul_shaders();
      init_transpose();
      calculateOutputShape = (inputShape, kernelShape, dilations, adjustPads, strides, isChannelLast) => {
        const batchSize = inputShape[0];
        const inputSpatialShape = inputShape.slice(isChannelLast ? 1 : 2, isChannelLast ? 3 : 4);
        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 outputShape = inputSpatialShapeWithPad.map(
          (v, i) => Math.floor((v - dilatedKernelShape[i] + strides[i]) / strides[i])
        );
        outputShape.splice(0, 0, batchSize);
        outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels);
        return outputShape;
      };
      weightTransposeAttribute = [2, 3, 1, 0];
      validateInputs8 = (inputs, attributes) => {
        if (!inputs || inputs.length !== 2 && inputs.length !== 3) {
          throw new Error("Conv requires 2 or 3 inputs");
        }
        if (inputs[0].dims.length > 5) {
          throw new Error("greater than 5D is not supported");
        }
        if (inputs[0].dims.length !== inputs[1].dims.length) {
          throw new Error("filter does not have same dimension as input");
        }
        const dataChannel = inputs[0].dims[attributes.format === "NHWC" ? inputs[0].dims.length - 1 : 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");
        }
      };
      getAdjustedConvAttributes = (attributes, inputs) => {
        const kernelShape = attributes.kernelShape.slice();
        if (kernelShape.length < inputs[1].dims.length - 2) {
          kernelShape.push(...Array(inputs[1].dims.length - 2 - kernelShape.length).fill(0));
        }
        for (let i = 2; i < inputs[1].dims.length; ++i) {
          if (kernelShape[i - 2] === 0) {
            kernelShape[i - 2] = inputs[1].dims[i];
          }
        }
        const pads = attributes.pads.slice();
        PoolConvUtil.adjustPadsBasedOnAutoPad(
          inputs[0].dims,
          attributes.strides,
          attributes.dilations,
          kernelShape,
          pads,
          attributes.format === "NHWC",
          attributes.autoPad
        );
        const newAttributes = Object.assign({}, attributes);
        Object.assign(newAttributes, { kernelShape, pads });
        return newAttributes;
      };
      parseConvAttributes = (attributes) => {
        const activationAttributes = parseInternalActivationAttributes(attributes);
        const format = attributes.format;
        const autoPad = ["NOTSET", "VALID", "SAME_UPPER", "SAME_LOWER"][attributes.auto_pad];
        const dilations = attributes.dilations;
        const group = attributes.group;
        const kernelShape = attributes.kernel_shape;
        const pads = attributes.pads;
        const strides = attributes.strides;
        const wIsConst = attributes.w_is_const();
        return {
          autoPad,
          format,
          dilations,
          group,
          kernelShape,
          pads,
          strides,
          wIsConst,
          ...activationAttributes,
          cacheKey: `${attributes.format};${activationAttributes.activation};`
        };
      };
      conv2d = (context, inputs, attributes, squeezeOutputShapeFunction) => {
        const isChannelsLast = attributes.format === "NHWC";
        const outputShape = calculateOutputShape(
          inputs[0].dims,
          inputs[1].dims,
          attributes.dilations,
          attributes.pads,
          attributes.strides,
          isChannelsLast
        );
        if (attributes.group !== 1) {
          const convInputs2 = [inputs[0]];
          if (isChannelsLast) {
            const transposedWeight2 = context.kernelCustomData.wT ?? context.compute(createTransposeProgramInfo(inputs[1], weightTransposeAttribute), {
              inputs: [1],
              outputs: [attributes.wIsConst ? -2 : -1]
            })[0];
            if (attributes.wIsConst && !context.kernelCustomData.wT) {
              context.kernelCustomData.wT = transposedWeight2;
            }
            convInputs2.push(transposedWeight2);
          } else {
            convInputs2.push(inputs[1]);
          }
          if (inputs.length === 3) {
            convInputs2.push(inputs[2]);
          }
          const enableGroupedConvVectorize = !context.adapterInfo.isArchitecture("ampere");
          if (enableGroupedConvVectorize && isChannelsLast && inputs[1].dims[0] === attributes.group && inputs[1].dims[1] === 1 && attributes.dilations[0] === 1 && attributes.dilations[1] === 1) {
            context.compute(
              createGroupedConvVectorizeProgramInfo(convInputs2, attributes, outputShape, squeezeOutputShapeFunction),
              { inputs: convInputs2 }
            );
          } else {
            context.compute(createGroupedConvProgramInfo(convInputs2, attributes, outputShape, squeezeOutputShapeFunction), {
              inputs: convInputs2
            });
          }
          return;
        }
        const hasBias = inputs.length === 3;
        const inputHeight = inputs[0].dims[isChannelsLast ? 1 : 2];
        const inputWidth = inputs[0].dims[isChannelsLast ? 2 : 3];
        const inputChannels = inputs[0].dims[isChannelsLast ? 3 : 1];
        const weightHeight = inputs[1].dims[2];
        const weightWidth = inputs[1].dims[3];
        const outHeight = outputShape[isChannelsLast ? 1 : 2];
        const outWidth = outputShape[isChannelsLast ? 2 : 3];
        const outChannels = outputShape[isChannelsLast ? 3 : 1];
        const sameSize = isChannelsLast && weightHeight === inputHeight && weightWidth === inputWidth && attributes.pads[0] === 0 && attributes.pads[1] === 0;
        if (sameSize || weightHeight === 1 && weightWidth === 1 && attributes.dilations[0] === 1 && attributes.dilations[1] === 1 && attributes.strides[0] === 1 && attributes.strides[1] === 1 && attributes.pads[0] === 0 && attributes.pads[1] === 0) {
          const batch = outputShape[0];
          let xReshaped, wReshaped, matmulOutputShape;
          const matmulInputs = [];
          if (isChannelsLast) {
            const transposedWeight2 = context.kernelCustomData.wT ?? context.compute(createTransposeProgramInfo(inputs[1], weightTransposeAttribute), {
              inputs: [1],
              outputs: [attributes.wIsConst ? -2 : -1]
            })[0];
            if (attributes.wIsConst && !context.kernelCustomData.wT) {
              context.kernelCustomData.wT = transposedWeight2;
            }
            if (sameSize) {
              const sharedDim = inputHeight * inputWidth * inputChannels;
              xReshaped = inputs[0].reshape([1, batch, sharedDim]);
              wReshaped = transposedWeight2.reshape([1, sharedDim, outChannels]);
              matmulOutputShape = [1, batch, outChannels];
            } else {
              xReshaped = inputs[0].reshape([batch, inputHeight * inputWidth, inputChannels]);
              wReshaped = transposedWeight2.reshape([1, inputChannels, outChannels]);
              matmulOutputShape = [batch, outHeight * outWidth, outChannels];
            }
            matmulInputs.push(xReshaped);
            matmulInputs.push(wReshaped);
          } else {
            xReshaped = inputs[0].reshape([batch, inputChannels, inputHeight * inputWidth]);
            wReshaped = inputs[1].reshape([1, outChannels, inputChannels]);
            matmulOutputShape = [batch, outChannels, outHeight * outWidth];
            matmulInputs.push(wReshaped);
            matmulInputs.push(xReshaped);
          }
          if (hasBias) {
            matmulInputs.push(inputs[2]);
          }
          const N = matmulOutputShape[2];
          const K = matmulInputs[0].dims[matmulInputs[0].dims.length - 1];
          if (N < 8 && K < 8) {
            context.compute(
              createNaiveMatmulProgramInfo(
                matmulInputs,
                attributes,
                outputShape,
                matmulOutputShape,
                isChannelsLast,
                squeezeOutputShapeFunction
              ),
              { inputs: matmulInputs }
            );
          } else {
            context.compute(
              createMatmulProgramInfo(
                matmulInputs,
                attributes,
                outputShape,
                matmulOutputShape,
                isChannelsLast,
                squeezeOutputShapeFunction
              ),
              { inputs: matmulInputs }
            );
          }
          return;
        }
        const sequentialAccessByThreads = (
          /* backend.adapterInfo.isIntel() */
          true
        );
        const transposedWeight = context.kernelCustomData.wT ?? context.compute(createTransposeProgramInfo(inputs[1], weightTransposeAttribute), {
          inputs: [1],
          outputs: [attributes.wIsConst ? -2 : -1]
        })[0];
        if (attributes.wIsConst && !context.kernelCustomData.wT) {
          context.kernelCustomData.wT = transposedWeight;
        }
        const convInputs = [inputs[0], transposedWeight];
        if (hasBias) {
          convInputs.push(inputs[2]);
        }
        const dimAOuter = isChannelsLast ? outHeight * outWidth : outChannels;
        const dimBOuter = isChannelsLast ? outChannels : outHeight * outWidth;
        const dimInner = weightHeight * weightWidth * inputChannels;
        context.compute(
          createConv2DMatMulProgramInfo(
            convInputs,
            attributes,
            outputShape,
            dimAOuter,
            dimBOuter,
            dimInner,
            hasBias,
            sequentialAccessByThreads,
            squeezeOutputShapeFunction
          ),
          { inputs: convInputs }
        );
      };
      conv1d = (context, attributes) => {
        const isChannelLast = attributes.format === "NHWC";
        const inputs = [
          context.inputs[0].reshape(
            isChannelLast ? (
              // [N, W, C] -> [N, H=1, W, C]
              [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]]
            ) : (
              // [N, C, W] -> [N, C, H=1, W]
              [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]]
            )
          ),
          //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW]
          context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]])
        ];
        if (context.inputs.length === 3) {
          inputs.push(context.inputs[2]);
        }
        const pads = [0, attributes.pads[0], 0, attributes.pads[1]];
        const strides = [1].concat(attributes.strides);
        const dilations = [1].concat(attributes.dilations);
        const kernelShape = [1].concat(attributes.kernelShape);
        const adjustedAttributes = getAdjustedConvAttributes(
          { ...attributes, pads, strides, dilations, kernelShape },
          inputs
        );
        conv2d(
          context,
          inputs,
          adjustedAttributes,
          (outputShape) => isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] : [outputShape[0], outputShape[1], outputShape[3]]
        );
      };
      conv3d = (context, inputs, attributes) => {
        const format = attributes.format === "NHWC" ? "channelsLast" : "channelsFirst";
        const adjustedAttributes = getAdjustedConvAttributes(attributes, inputs);
        const pads = attributes.autoPad === "NOTSET" ? attributes.pads : attributes.autoPad;
        const convInfo = computeConv3DInfo(
          inputs[0].dims,
          inputs[1].dims,
          attributes.strides,
          attributes.dilations,
          pads,
          false,
          format
        );
        context.compute(
          createConv3DNaiveProgramInfo(
            inputs,
            adjustedAttributes,
            convInfo.outShape,
            [convInfo.filterDepth, convInfo.filterHeight, convInfo.filterWidth],
            [convInfo.padInfo.front, convInfo.padInfo.top, convInfo.padInfo.left],
            format
          )
        );
      };
      conv = (context, attributes) => {
        validateInputs8(context.inputs, attributes);
        if (context.inputs[0].dims.length === 3) {
          conv1d(context, attributes);
        } else if (context.inputs[0].dims.length === 5) {
          conv3d(context, context.inputs, attributes);
        } else {
          const adjustedAttributes = getAdjustedConvAttributes(attributes, context.inputs);
          conv2d(context, context.inputs, adjustedAttributes);
        }
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_webgpu.ts
  var createConvTranspose2DProgramInfo;
  var init_conv_backprop_webgpu = __esm({
    "web/lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_webgpu.ts"() {
      "use strict";
      init_wasm_common();
      init_log();
      init_util();
      init_common();
      createConvTranspose2DProgramInfo = (inputs, attributes, squeezeOutputShapeFunction) => {
        const hasBias = inputs.length > 2;
        const outputShape = attributes.outputShape;
        const isChannelsLast = attributes.format === "NHWC";
        const group = attributes.group;
        const wShape = inputs[1].dims;
        const inputChannelsPerGroup = wShape[2] / group;
        const outputChannelsPerGroup = wShape[3];
        const aComponents = isChannelsLast ? getMaxComponents(inputChannelsPerGroup) : 1;
        const packInputAs4 = isChannelsLast && outputChannelsPerGroup === 1 && inputChannelsPerGroup >= 4;
        const inputChannelsPerGroupInt = packInputAs4 ? Math.floor(inputChannelsPerGroup / 4) * 4 : Math.floor(inputChannelsPerGroup / aComponents) * aComponents;
        const inputChannelsRemainder = inputChannelsPerGroup - inputChannelsPerGroupInt;
        const components = isChannelsLast ? getMaxComponents(outputChannelsPerGroup) : 1;
        const bComponents = isChannelsLast ? outputChannelsPerGroup === 1 ? aComponents : components : 1;
        const outputSize = ShapeUtil.size(outputShape) / components;
        const dispatch = [Math.ceil(outputSize / 64), 1, 1];
        LOG_DEBUG("verbose", () => `[conv2d_backprop_webgpu] dispatch = ${dispatch}`);
        const inputDependencies = ["rank", "rank"];
        const strides = [attributes.strides[0], attributes.strides[1]];
        const filterDims = [attributes.kernelShape[isChannelsLast ? 1 : 2], attributes.kernelShape[isChannelsLast ? 2 : 3]];
        const dilations = [attributes.dilations[0], attributes.dilations[1]];
        const effectiveFilterDims = [
          filterDims[0] + (attributes.dilations[0] <= 1 ? 0 : (attributes.kernelShape[isChannelsLast ? 1 : 2] - 1) * (attributes.dilations[0] - 1)),
          filterDims[1] + (attributes.dilations[1] <= 1 ? 0 : (attributes.kernelShape[isChannelsLast ? 2 : 3] - 1) * (attributes.dilations[1] - 1))
        ];
        const pads = [
          effectiveFilterDims[0] - 1 - Math.floor((attributes.pads[0] + attributes.pads[2]) / 2),
          effectiveFilterDims[1] - 1 - Math.floor((attributes.pads[1] + attributes.pads[3]) / 2)
        ];
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 12 /* uint32 */, data: strides },
          { type: 12 /* uint32 */, data: filterDims },
          { type: 12 /* uint32 */, data: dilations },
          { type: 12 /* uint32 */, data: effectiveFilterDims },
          { type: 6 /* int32 */, data: pads },
          { type: 12 /* uint32 */, data: inputChannelsPerGroupInt },
          { type: 12 /* uint32 */, data: inputChannelsPerGroup },
          { type: 12 /* uint32 */, data: outputChannelsPerGroup },
          ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims)
        ];
        if (hasBias) {
          programUniforms.push(...createTensorShapeVariables(inputs[2].dims));
          inputDependencies.push("rank");
        }
        programUniforms.push(...createTensorShapeVariables(outputShape));
        const getShaderSource = (shaderHelper) => {
          const uniforms = [
            { name: "output_size", type: "u32" },
            { name: "strides", type: "u32", length: strides.length },
            { name: "filter_dims", type: "u32", length: filterDims.length },
            { name: "dilations", type: "u32", length: filterDims.length },
            { name: "effective_filter_dims", type: "u32", length: effectiveFilterDims.length },
            { name: "pads", type: "i32", length: pads.length },
            { name: "input_channels_per_group_int", type: "u32" },
            { name: "input_channels_per_group", type: "u32" },
            { name: "output_channels_per_group", type: "u32" }
          ];
          const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);
          const rowDim = isChannelsLast ? 1 : 2;
          const colDim = isChannelsLast ? 2 : 3;
          const channelDim = isChannelsLast ? 3 : 1;
          const w = inputVariable("W", inputs[1].dataType, inputs[1].dims.length, bComponents);
          const dy = inputVariable("Dy", inputs[0].dataType, inputs[0].dims.length, aComponents);
          const inputVariables = [dy, w];
          if (hasBias) {
            inputVariables.push(inputVariable("bias", inputs[2].dataType, [outputShape[channelDim]].length, components));
          }
          const output = outputVariable("result", inputs[0].dataType, outputShape.length, components);
          const calculateResult = () => {
            let calcStr = "";
            if (packInputAs4) {
              if (aComponents === 4) {
                calcStr += `
        let xValue = ${dy.getByOffset("x_offset")};
        let wValue = ${w.getByOffset("w_offset")};
        dotProd = dotProd + dot(xValue, wValue);
        x_offset += 1u;
        w_offset += 1u;`;
              } else if (aComponents === 2) {
                calcStr += `
          dotProd = dotProd + dot(vec4<${dataType}>(${dy.getByOffset("x_offset")}, ${dy.getByOffset("x_offset + 1u")}), vec4<${dataType}>(${w.getByOffset("w_offset")}, ${w.getByOffset("w_offset + 1u")}));
          x_offset += 2u;
          w_offset += 2u;`;
              } else if (aComponents === 1) {
                calcStr += `
          dotProd = dotProd + dot(vec4<${dataType}>(${dy.getByOffset("x_offset")}, ${dy.getByOffset("x_offset + 1u")}, ${dy.getByOffset("x_offset + 2u")}, ${dy.getByOffset("x_offset + 3u")}), vec4<${dataType}>(${w.getByOffset("w_offset")}, ${w.getByOffset("w_offset + 1u")}, ${w.getByOffset("w_offset + 2u")}, ${w.getByOffset("w_offset + 3u")}));
          x_offset += 4u;
          w_offset += 4u;`;
              }
            } else {
              calcStr += `
                  let xValue = ${isChannelsLast ? dy.getByOffset(
                `${dy.indicesToOffset(`${dy.type.indices}(batch, idyR, idyC, inputChannel)`)} / ${aComponents}`
              ) : dy.get("batch", "inputChannel", "idyR", "idyC")};
        `;
              if (aComponents === 1) {
                calcStr += `
          let w_offset = ${w.indicesToOffset(`${w.type.indices}(u32(wRPerm), u32(wCPerm), inputChannel, wOutChannel)`)};
          let wValue = ${w.getByOffset(`w_offset / ${bComponents}`)};
          dotProd = dotProd + xValue * wValue;`;
              } else {
                for (let c = 0; c < aComponents; c++) {
                  calcStr += `
            let wValue${c} = ${w.getByOffset(`${w.indicesToOffset(`${w.type.indices}(u32(wRPerm), u32(wCPerm), inputChannel + ${c}, wOutChannel)`)} / ${bComponents}`)};
            dotProd = dotProd + xValue[${c}] * wValue${c};`;
                }
              }
            }
            return calcStr;
          };
          const calculateRemainder = () => {
            if (inputChannelsRemainder === 0) {
              return "";
            }
            if (!packInputAs4) {
              throw new Error(`packInputAs4 ${packInputAs4} is not true.`);
            }
            let calcStr = "";
            if (aComponents === 1) {
              calcStr += "dotProd = dotProd";
              for (let i = 0; i < inputChannelsRemainder; i++) {
                calcStr += `
            + ${dy.getByOffset(`x_offset + ${i}`)} * ${w.getByOffset(`w_offset + ${i}`)}`;
              }
              calcStr += ";";
            } else if (aComponents === 2) {
              if (inputChannelsRemainder !== 2) {
                throw new Error(`Invalid inputChannelsRemainder ${inputChannelsRemainder}.`);
              }
              calcStr += `
          let xValue = ${dy.getByOffset("x_offset")};
          let wValue = ${w.getByOffset("w_offset")};
          dotProd = dotProd + dot(xValue, wValue);`;
            }
            return calcStr;
          };
          const codeSnippet = `
            let outputIndices = ${output.offsetToIndices(`global_idx * ${components}`)};
            let batch = ${output.indicesGet("outputIndices", 0)};
            let d1 = ${output.indicesGet("outputIndices", channelDim)};
            let r = ${output.indicesGet("outputIndices", rowDim)};
            let c = ${output.indicesGet("outputIndices", colDim)};
            let dyCorner = vec2<i32>(i32(r), i32(c)) - uniforms.pads;
            let dyRCorner = dyCorner.x;
            let dyCCorner = dyCorner.y;
            let groupId = d1 / uniforms.output_channels_per_group;
            let wOutChannel = d1 - groupId * uniforms.output_channels_per_group;
            // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1).
            // ? = to be determined. : = across all values in that axis.
            var dotProd = ${output.type.value}(0.0);
            var wR: u32 = 0;
            if (uniforms.dilations.x == 1) {
              // Minimum wR >= 0 that satisfies (dyRCorner + wR) % (uniforms.strides.x) == 0
              wR = u32(((dyRCorner + i32(uniforms.strides.x) - 1) / i32(uniforms.strides.x)) * i32(uniforms.strides.x) - dyRCorner);
            }
            for (; wR < uniforms.effective_filter_dims.x; wR = wR + 1) {
              if (wR % uniforms.dilations.x != 0) {
                continue;
              }
              let dyR = (${dataType}(dyRCorner) + ${dataType}(wR)) / ${dataType}(uniforms.strides[0]);
              let wRPerm = uniforms.filter_dims.x - 1 - wR / uniforms.dilations.x;
              if (dyR < 0.0 || dyR >= ${dataType}(uniforms.Dy_shape[${rowDim}]) || fract(dyR) > 0.0 ||
                  wRPerm < 0) {
                continue;
              }
              let idyR: u32 = u32(dyR);
              var wC: u32 = 0;
              if (uniforms.dilations.y == 1) {
                // Minimum wC >= 0 that satisfies (dyCCorner + wC) % (uniforms.strides.y) == 0
                wC = u32(((dyCCorner + i32(uniforms.strides.y) - 1) / i32(uniforms.strides.y)) * i32(uniforms.strides.y) - dyCCorner);
              }
              for (; wC < uniforms.effective_filter_dims.y; wC = wC + 1) {
                if (wC % uniforms.dilations.y != 0) {
                  continue;
                }
                let dyC = (${dataType}(dyCCorner) + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);
                let wCPerm = uniforms.filter_dims.y - 1 - wC / uniforms.dilations.y;
                if (dyC < 0.0 || dyC >= ${dataType}(uniforms.Dy_shape[${colDim}]) ||
                    fract(dyC) > 0.0 || wCPerm < 0) {
                  continue;
                }
                let idyC: u32 = u32(dyC);
                var inputChannel = groupId * uniforms.input_channels_per_group;
                ${packInputAs4 ? `
                var x_offset = ${dy.indicesToOffset(`${dy.type.indices}(batch, idyR, idyC, inputChannel)`)} / ${aComponents};
                var w_offset = ${w.indicesToOffset(`${w.type.indices}(wRPerm, wCPerm, inputChannel, wOutChannel)`)} / ${bComponents};
                  ` : ""}
                for (var d2: u32 = 0; d2 < uniforms.input_channels_per_group_int; d2 = d2 + ${packInputAs4 ? 4 : aComponents}) {
                  ${calculateResult()}
                  inputChannel = inputChannel + ${packInputAs4 ? 4 : aComponents};
                }
                ${calculateRemainder()}
                wC = wC + uniforms.strides.y - 1;
              }
              wR = wR + uniforms.strides[0] - 1;
            }
            let value = dotProd${hasBias ? ` + bias[d1 / ${components}]` : ""};
            ${output.setByOffset("global_idx", "value")};
          `;
          return `
    ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}
      ${shaderHelper.mainStart()}
      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")};
    ${codeSnippet}}`;
        };
        return {
          name: "ConvTranspose2D",
          shaderCache: {
            hint: `${attributes.cacheKey};${aComponents}${bComponents}${components}${packInputAs4}${inputChannelsRemainder}`,
            inputDependencies
          },
          getRunData: () => ({
            dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },
            outputs: [
              {
                dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,
                dataType: inputs[0].dataType
              }
            ],
            programUniforms
          }),
          getShaderSource
        };
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/conv-transpose.ts
  var computeTotalPad, distributePadding, calculateOutputShapeAndPads, getAdjustedConvTransposeAttributes, parseConvTransposeAttributes, validateInputs9, convTranspose2d, convTranspose1d, convTranspose;
  var init_conv_transpose = __esm({
    "web/lib/wasm/jsep/webgpu/ops/conv-transpose.ts"() {
      "use strict";
      init_conv_backprop_webgpu();
      init_fuse_utils();
      init_transpose();
      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, group, pads, strides, isChannelLast, outputPadding, outputShape) => {
        const spatialRank = inputShape.length - 2;
        const updateOutputShape = outputShape.length === 0;
        if (outputPadding.length < spatialRank) {
          outputPadding.push(...Array(spatialRank - outputPadding.length).fill(0));
        }
        const batchSize = inputShape[0];
        const outChannels = kernelShape[isChannelLast ? 3 : 1] * group;
        for (let i = 0, j = inputShape.length - spatialRank - (isChannelLast ? 1 : 0); i < spatialRank; ++i, ++j) {
          const inSize = inputShape[j];
          const outSize = updateOutputShape ? inSize * strides[i] : outputShape[i];
          const totalPad = computeTotalPad(inSize, strides[i], pads[i], kernelShape[j], dilations[i], outSize);
          distributePadding(totalPad, autoPad, pads, i, i + spatialRank);
          if (updateOutputShape) {
            outputShape.push(
              strides[i] * (inSize - 1) + outputPadding[i] + (kernelShape[j] - 1) * dilations[i] + 1 - pads[i] - pads[i + spatialRank]
            );
          }
        }
        outputShape.splice(0, 0, batchSize);
        outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels);
      };
      getAdjustedConvTransposeAttributes = (attributes, inputs) => {
        const kernelShape = attributes.kernelShape.slice();
        if (attributes.kernelShape.length === 0 || attributes.kernelShape.reduce((a, b) => a * b, 1) === 0) {
          kernelShape.length = 0;
          for (let i = 2; i < inputs[1].dims.length; ++i) {
            kernelShape.push(inputs[1].dims[i]);
          }
        }
        const isChannelsLast = attributes.format === "NHWC";
        kernelShape.splice(0, 0, inputs[1].dims[0]);
        kernelShape.splice(isChannelsLast ? 3 : 1, 0, inputs[1].dims[1]);
        const pads = attributes.pads.slice();
        const outputShape = attributes.outputShape.slice();
        const outputPadding = attributes.outputPadding.slice();
        const inputShape = inputs[0].dims;
        let dilations = attributes.dilations.slice();
        if (dilations.reduce((a, b) => a + b, 0) === 0) {
          const spatialRank = inputs[0].dims.length - 2;
          dilations = new Array(spatialRank).fill(1);
        }
        let strides = attributes.strides.slice();
        if (strides.reduce((a, b) => a + b, 0) === 0) {
          const spatialRank = inputs[0].dims.length - 2;
          strides = new Array(spatialRank).fill(1);
        }
        calculateOutputShapeAndPads(
          inputShape,
          kernelShape,
          dilations,
          attributes.autoPad,
          attributes.group,
          pads,
          strides,
          isChannelsLast,
          outputPadding,
          outputShape
        );
        const newAttributes = Object.assign({}, attributes);
        Object.assign(newAttributes, { kernelShape, pads, outputPadding, outputShape, dilations, strides });
        return newAttributes;
      };
      parseConvTransposeAttributes = (attributes) => {
        const activationAttributes = parseInternalActivationAttributes(attributes);
        const format = attributes.format;
        const autoPad = ["NOTSET", "VALID", "SAME_UPPER", "SAME_LOWER"][typeof attributes.autoPad == "undefined" ? 0 : attributes.autoPad];
        const dilations = attributes.dilations;
        const group = attributes.group ?? 1;
        const kernelShape = attributes.kernelShape;
        const pads = attributes.pads;
        const strides = attributes.strides;
        const wIsConst = attributes.wIsConst();
        const outputPadding = attributes.outputPadding;
        const outputShape = attributes.outputShape;
        return {
          autoPad,
          format,
          dilations,
          group,
          kernelShape,
          outputPadding,
          outputShape,
          pads,
          strides,
          wIsConst,
          ...activationAttributes,
          cacheKey: `${attributes.format};${activationAttributes.activation};`
        };
      };
      validateInputs9 = (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[0].dims.length !== 3) {
          throw new Error("currently only support 2-dimensional conv");
        }
        if (inputs[0].dims.length !== inputs[1].dims.length) {
          throw new Error("filter does not have same dimension as input");
        }
        const dataChannel = inputs[0].dims[attributes.format === "NHWC" ? inputs[0].dims.length - 1 : 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;
        const dilationsSet = attributes.dilations.reduce((a, b) => a + b, 0) > 0;
        if (dilationsSet && attributes.dilations.length !== spatialRank) {
          throw new Error(`dilations should be ${spatialRank}D`);
        }
        const stridesSet = attributes.strides.reduce((a, b) => a + b, 0) > 0;
        if (stridesSet && attributes.strides.length !== spatialRank) {
          throw new Error(`strides should be ${spatialRank}D`);
        }
        const padsSet = attributes.pads.reduce((a, b) => a + b, 0) > 0;
        if (padsSet && attributes.pads.length !== spatialRank * 2) {
          throw new Error(`pads should be ${spatialRank * 2}D`);
        }
        if (attributes.outputPadding.length !== spatialRank && attributes.outputPadding.length !== 0) {
          throw new Error(`output_padding should be ${spatialRank}D`);
        }
        const kernelShapeSet = attributes.kernelShape.reduce((a, b) => a + b, 0) > 0;
        if (kernelShapeSet && 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");
        }
      };
      convTranspose2d = (context, inputs, attributes, squeezeOutputShapeFunction) => {
        const transposedWeight = context.kernelCustomData.wT ?? context.compute(createTransposeProgramInfo(inputs[1], [2, 3, 0, 1]), {
          inputs: [1],
          outputs: [attributes.wIsConst ? -2 : -1]
        })[0];
        if (attributes.wIsConst && !context.kernelCustomData.wT) {
          context.kernelCustomData.wT = transposedWeight;
        }
        const convTransposeInputs = [inputs[0], transposedWeight];
        if (inputs.length === 3) {
          convTransposeInputs.push(inputs[2]);
        }
        context.compute(createConvTranspose2DProgramInfo(convTransposeInputs, attributes, squeezeOutputShapeFunction), {
          inputs: convTransposeInputs
        });
      };
      convTranspose1d = (context, attributes) => {
        const isChannelLast = attributes.format === "NHWC";
        const inputs = [
          context.inputs[0].reshape(
            isChannelLast ? (
              // [N, W, C] -> [N, H=1, W, C]
              [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]]
            ) : (
              // [N, C, W] -> [N, C, H=1, W]
              [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]]
            )
          ),
          //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW]
          context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]])
        ];
        if (context.inputs.length === 3) {
          inputs.push(context.inputs[2]);
        }
        let kernelShape = attributes.kernelShape;
        if (kernelShape.length === 0 || kernelShape[0] === 0) {
          kernelShape = [context.inputs[1].dims[2]];
        }
        let dilations = attributes.dilations;
        if (dilations.length === 0 || dilations[0] === 0) {
          dilations = [1];
        }
        let strides = attributes.strides;
        if (strides.length === 0 || strides[0] === 0) {
          strides = [1];
        }
        let pads = attributes.pads;
        if (pads.length === 0) {
          pads = [0, 0];
        }
        pads = [0, pads[0], 0, pads[1]];
        strides = [1].concat(strides);
        dilations = [1].concat(dilations);
        kernelShape = [1].concat(kernelShape);
        let outputPadding = attributes.outputPadding;
        outputPadding = [0].concat(outputPadding);
        const adjustedAttributes = getAdjustedConvTransposeAttributes(
          { ...attributes, pads, strides, dilations, kernelShape, outputPadding },
          inputs
        );
        convTranspose2d(
          context,
          inputs,
          adjustedAttributes,
          (outputShape) => isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] : [outputShape[0], outputShape[1], outputShape[3]]
        );
      };
      convTranspose = (context, attributes) => {
        validateInputs9(context.inputs, attributes);
        if (context.inputs[0].dims.length === 3) {
          convTranspose1d(context, attributes);
        } else {
          const adjustedAttributes = getAdjustedConvTransposeAttributes(attributes, context.inputs);
          convTranspose2d(context, context.inputs, adjustedAttributes);
        }
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/cumsum.ts
  var createCumsumProgramInfo, cumsum, parseCumSumAttributes;
  var init_cumsum = __esm({
    "web/lib/wasm/jsep/webgpu/ops/cumsum.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      createCumsumProgramInfo = (inputType, inputShape, axisInput, attributes) => {
        const outputSize = ShapeUtil.size(inputShape);
        const rank = inputShape.length;
        const input = inputVariable("input", inputType, rank);
        const output = outputVariable("output", inputType, rank);
        const axisValue = axisInput.dataType === 6 /* int32 */ ? axisInput.getInt32Array()[0] : Number(axisInput.getBigInt64Array()[0]);
        const axis = ShapeUtil.normalizeAxis(axisValue, rank);
        const getShaderSource = (shaderHelper) => {
          const index = ` i32(${input.indicesGet("inputIndices", "uniforms.axis")}) `;
          const max = getElementAt("uniforms.input_shape", "uniforms.axis", rank);
          const lowerLimit = attributes.reverse ? index + (attributes.exclusive ? " + 1" : "") : "0";
          const upperLimit = attributes.reverse ? max : index + (attributes.exclusive ? "" : " + 1");
          return `
                ${shaderHelper.registerUniform("outputSize", "u32").registerUniform("axis", "u32").declareVariables(input, output)}
                ${shaderHelper.mainStart()}
                  ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}
                  var inputIndices = ${output.offsetToIndices("global_idx")};
                  var sum = ${output.type.value}(0);
                  let first : i32 = ${lowerLimit};
                  let last : i32 = ${upperLimit};
                  for (var i : i32 = first; i < last; i++) {
                    ${input.indicesSet("inputIndices", "uniforms.axis", "u32(i)")};
                    sum = sum + ${input.getByIndices("inputIndices")};
                  }
                  ${output.setByOffset("global_idx", "sum")};
                }`;
        };
        return {
          name: "CumSum",
          shaderCache: { hint: attributes.cacheKey, inputDependencies: ["rank"] },
          getRunData: () => ({
            outputs: [{ dims: inputShape, dataType: inputType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms: [
              { type: 12 /* uint32 */, data: outputSize },
              { type: 12 /* uint32 */, data: axis },
              ...createTensorShapeVariables(inputShape, inputShape)
            ]
          }),
          getShaderSource
        };
      };
      cumsum = (context, attributes) => {
        const inputShape = context.inputs[0].dims;
        const inputType = context.inputs[0].dataType;
        const axis = context.inputs[1];
        context.compute(createCumsumProgramInfo(inputType, inputShape, axis, attributes), { inputs: [0] });
      };
      parseCumSumAttributes = (attributes) => {
        const exclusive = attributes.exclusive === 1;
        const reverse = attributes.reverse === 1;
        return createAttributeWithCacheKey({ exclusive, reverse });
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/depth-to-space.ts
  var validateInputs10, permFunctionBody2, createDepthToSpaceProgramInfo, depthToSpace, parseDepthToSpaceAttributes;
  var init_depth_to_space = __esm({
    "web/lib/wasm/jsep/webgpu/ops/depth-to-space.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      validateInputs10 = (inputs) => {
        if (!inputs || inputs.length !== 1) {
          throw new Error("DepthToSpace requires 1 input.");
        }
        if (inputs[0].dims.length !== 4) {
          throw new Error("DepthToSpace requires 4D input.");
        }
      };
      permFunctionBody2 = (perm, rank, input, output) => {
        const reverseFunc = [];
        reverseFunc.push(`fn perm(i: ${output.type.indices}) -> ${input.type.indices} {
    var a: ${input.type.indices};`);
        for (let i = 0; i < rank; ++i) {
          reverseFunc.push(input.indicesSet("a", perm[i], `i[${i}]`));
        }
        reverseFunc.push("return a;}");
        return reverseFunc.join("\n");
      };
      createDepthToSpaceProgramInfo = (inputTensor, attributes) => {
        let n, h, w, c;
        let shape;
        let perm;
        const isChannelLast = attributes.format === "NHWC";
        const blocksize = attributes.blocksize;
        const isDCRmode = attributes.mode === "DCR";
        if (isChannelLast) {
          [n, h, w, c] = inputTensor.dims;
          shape = isDCRmode ? [n, h, w, blocksize, blocksize, c / blocksize ** 2] : [n, h, w, c / blocksize ** 2, blocksize, blocksize];
          perm = isDCRmode ? [0, 1, 3, 2, 4, 5] : [0, 1, 4, 2, 5, 3];
        } else {
          [n, h, w, c] = [inputTensor.dims[0], inputTensor.dims[2], inputTensor.dims[3], inputTensor.dims[1]];
          shape = isDCRmode ? [n, blocksize, blocksize, c / blocksize ** 2, h, w] : [n, c / blocksize ** 2, blocksize, blocksize, h, w];
          perm = isDCRmode ? [0, 3, 4, 1, 5, 2] : [0, 1, 4, 2, 5, 3];
        }
        const reshapedInputTensor = inputTensor.reshape(shape);
        const reshapedInputRank = reshapedInputTensor.dims.length;
        const inputDataType = inputTensor.dataType;
        const reshapedInput = inputVariable("a", inputDataType, reshapedInputRank);
        const permedOutput = outputVariable("output", inputDataType, reshapedInputRank);
        const getShaderSource = (shaderHelper) => `
  ${shaderHelper.registerUniform("output_size", "u32").declareVariables(reshapedInput, permedOutput)}

  ${permFunctionBody2(perm, reshapedInputRank, reshapedInput, permedOutput)}

  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}

    let indices = ${permedOutput.offsetToIndices("global_idx")};
    let aIndices = perm(indices);

    ${permedOutput.setByOffset("global_idx", reshapedInput.getByIndices("aIndices"))}
  }`;
        return {
          name: "DepthToSpace",
          shaderCache: {
            hint: `${inputTensor.dims};${attributes.blocksize};${attributes.mode}`,
            inputDependencies: ["rank"]
          },
          getRunData: (inputs) => {
            const outputShape = isChannelLast ? [n, h * blocksize, w * blocksize, c / blocksize ** 2] : [n, c / blocksize ** 2, h * blocksize, w * blocksize];
            const outputSize = ShapeUtil.size(outputShape);
            const shapeBeforePerm = reshapedInputTensor.dims;
            const shapeAfterPerm = ShapeUtil.sortBasedOnPerm(shapeBeforePerm, perm);
            return {
              outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],
              dispatchGroup: { x: Math.ceil(
                outputSize / 64
                /* workgroup size */
              ) },
              programUniforms: [
                { type: 12 /* uint32 */, data: outputSize },
                ...createTensorShapeVariables(shapeBeforePerm, shapeAfterPerm)
              ]
            };
          },
          getShaderSource
        };
      };
      depthToSpace = (context, attributes) => {
        validateInputs10(context.inputs);
        context.compute(createDepthToSpaceProgramInfo(context.inputs[0], attributes));
      };
      parseDepthToSpaceAttributes = (attributes) => createAttributeWithCacheKey({
        blocksize: attributes.blocksize,
        mode: attributes.mode,
        format: attributes.format
      });
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/einsum.ts
  var symbolPattern, termPattern, termPatternOnly, lhsPattern, lhsPatternOnly, EinsumTerm, EinsumEquation, appendMax, createEinsumProgramInfo, einsum, parseEinsumAttributes;
  var init_einsum = __esm({
    "web/lib/wasm/jsep/webgpu/ops/einsum.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      symbolPattern = "[a-zA-Z]|\\.\\.\\.";
      termPattern = "(" + symbolPattern + ")+";
      termPatternOnly = "^" + termPattern + "$";
      lhsPattern = "(" + termPattern + ",)*" + termPattern;
      lhsPatternOnly = "^" + lhsPattern + "$";
      EinsumTerm = class {
        constructor(inputIndex = -1) {
          this.symbolToIndices = /* @__PURE__ */ new Map();
          this.inputIndex = inputIndex;
        }
        // Add a symbol to the term
        addSymbol(symbol, index) {
          let value = this.symbolToIndices.get(symbol);
          if (value === void 0) {
            value = [index];
          } else {
            value.push(index);
          }
          this.symbolToIndices.set(symbol, value);
        }
        // -1 for output and 0, 1, 2, ... for inputs
      };
      EinsumEquation = class {
        constructor(inputs, equation) {
          this.equation = equation;
          this.hasEllipsis = false;
          this.symbolToInfo = /* @__PURE__ */ new Map();
          this.lhs = new Array();
          this.outputDims = [];
          let [lhs, rhs] = equation.includes("->") ? equation.split("->", 2) : [equation, ""];
          if (!lhs.match(RegExp(lhsPatternOnly))) {
            throw new Error("Invalid LHS term");
          }
          const inputTerms = lhs.split(",");
          inputTerms.forEach((inputTerm, index) => {
            const dims = inputs[index].dims.slice();
            if (!inputTerm.match(RegExp(termPatternOnly))) {
              throw new Error("Invalid LHS term");
            }
            const einsumTerm = this.processTerm(inputTerm, true, dims, index);
            this.lhs.push(einsumTerm);
          });
          if (rhs === "") {
            rhs += [...this.symbolToInfo.entries()].filter(([sym, info]) => info.count === 1 || sym === "...").map(([sym]) => sym).join("");
          } else {
            if (!rhs.match(RegExp(termPattern))) {
              throw new Error("Invalid RHS");
            }
          }
          const rhsSymbols = rhs.match(RegExp(symbolPattern, "g"));
          rhsSymbols?.forEach((symbol) => {
            if (symbol === "...") {
              this.outputDims = this.outputDims.concat(this.ellipsisDims);
            } else {
              const info = this.symbolToInfo.get(symbol);
              if (info === void 0) {
                throw new Error("Invalid RHS symbol");
              }
              this.outputDims.push(info.dimValue);
            }
          });
          this.rhs = this.processTerm(rhs, false, this.outputDims);
        }
        // End of EinsumEqation constructor
        // Add a symbol to the equation
        addSymbol(symbol, dimValue, inputIndex) {
          let info = this.symbolToInfo.get(symbol);
          if (info !== void 0) {
            if (info.dimValue !== dimValue && info.count !== 1) {
              throw new Error("Dimension mismatch");
            } else {
              info.count++;
              info.inputIndices.push(inputIndex);
            }
          } else {
            info = { count: 1, dimValue, inputIndices: [inputIndex] };
          }
          this.symbolToInfo.set(symbol, info);
        }
        // Process one input/output term
        processTerm(term, isInput, dims, index = -1) {
          const rank = dims.length;
          let ellipsis = false;
          let ellipsisDims = [];
          let nextDim = 0;
          if (!term.match(RegExp(termPatternOnly)) && !isInput && term !== "") {
            throw new Error("Invalid LHS term");
          }
          const indexSymbols = term.match(RegExp(symbolPattern, "g"));
          const einsumTerm = new EinsumTerm(index);
          indexSymbols?.forEach((symbol, i) => {
            if (symbol === "...") {
              if (ellipsis) {
                throw new Error("Only one ellipsis is allowed per input term");
              }
              ellipsis = true;
              const ellipsisDimLength = rank - indexSymbols.length + 1;
              if (ellipsisDimLength < 0) {
                throw new Error("Ellipsis out of bounds");
              }
              ellipsisDims = dims.slice(nextDim, nextDim + ellipsisDimLength);
              if (this.hasEllipsis) {
                if (this.ellipsisDims.length !== ellipsisDims.length || this.ellipsisDims.toString() !== ellipsisDims.toString()) {
                  throw new Error("Ellipsis dimensions mismatch");
                }
              } else if (isInput) {
                this.hasEllipsis = true;
                this.ellipsisDims = ellipsisDims;
              } else {
                throw new Error("Ellipsis must be specified in the LHS");
              }
              for (let j = 0; j < ellipsisDims.length; j++) {
                const symbol2 = String.fromCharCode("0".charCodeAt(0) + j);
                einsumTerm.addSymbol(symbol2, i + j);
                this.addSymbol(symbol2, dims[nextDim++], index);
              }
            } else {
              einsumTerm.addSymbol(symbol, i + (this.hasEllipsis ? this.ellipsisDims.length - 1 : 0));
              this.addSymbol(symbol, dims[nextDim++], index);
            }
          });
          return einsumTerm;
        }
        // Output dimensions of the equation
      };
      appendMax = (name) => name + "_max";
      createEinsumProgramInfo = (inputShapes, dataType, einsumEquation, outputShape) => {
        const ranks = inputShapes.map((dims) => dims.length);
        const inputVars = ranks.map((rank, index) => inputVariable(`input${index}`, dataType, rank));
        const outputSize = ShapeUtil.size(outputShape);
        const output = outputVariable("output", dataType, outputShape.length);
        const uniformsSymbols = [...einsumEquation.symbolToInfo.keys()].filter(
          (symbol) => !einsumEquation.rhs.symbolToIndices.has(symbol)
        );
        const getShaderSource = (shaderHelper) => {
          const idxCopy = [];
          const initProd = "var prod = 1.0;";
          const initSum = "var sum = 0.0;";
          const updateSum = "sum += prod;";
          const reduceOpsSetIndices = [];
          const reduceOpsLoopHeaders = [];
          const reduceOpsLoopFooters = [];
          const reduceOpCompute = [];
          const isReduceOpsWithoutLoop = einsumEquation.symbolToInfo.size === einsumEquation.rhs.symbolToIndices.size;
          einsumEquation.symbolToInfo.forEach((info, symbol) => {
            if (einsumEquation.rhs.symbolToIndices.has(symbol)) {
              const outputIndex = einsumEquation.rhs.symbolToIndices.get(symbol)?.[0];
              if (outputIndex !== void 0) {
                einsumEquation.lhs.forEach((term, i) => {
                  if (info.inputIndices.includes(i)) {
                    const indices = term.symbolToIndices.get(symbol);
                    if (indices === void 0) {
                      throw new Error("Invalid symbol error");
                    }
                    indices.forEach((index) => {
                      idxCopy.push(
                        `${inputVars[i].indicesSet(
                          `input${i}Indices`,
                          index,
                          output.indicesGet("outputIndices", outputIndex)
                        )}`
                      );
                    });
                  }
                });
              }
            } else {
              einsumEquation.lhs.forEach((term, i) => {
                if (info.inputIndices.includes(i)) {
                  const indices = term.symbolToIndices.get(symbol);
                  if (indices === void 0) {
                    throw new Error("Invalid symbol error");
                  }
                  indices.forEach((index) => {
                    reduceOpsSetIndices.push(`${inputVars[i].indicesSet(`input${i}Indices`, index, `${symbol}`)}`);
                  });
                  reduceOpCompute.push(`prod *= ${inputVars[i].getByIndices(`input${i}Indices`)};`);
                }
              });
              reduceOpsLoopHeaders.push(
                `for(var ${symbol}: u32 = 0; ${symbol} < uniforms.${appendMax(symbol)}; ${symbol}++) {`
              );
              reduceOpsLoopFooters.push("}");
            }
          });
          const reduceOps2 = isReduceOpsWithoutLoop ? [
            ...idxCopy,
            `let sum = ${inputVars.map((inputVar, i) => inputVar.getByIndices(`input${i}Indices`)).join(" * ")};`
          ] : [
            ...idxCopy,
            initSum,
            ...reduceOpsLoopHeaders,
            ...reduceOpsSetIndices,
            initProd,
            ...reduceOpCompute,
            updateSum,
            ...reduceOpsLoopFooters
          ];
          return `
            ${shaderHelper.registerUniforms(uniformsSymbols.map((symbol) => ({ name: `${appendMax(symbol)}`, type: "u32" }))).registerUniform("outputSize", "u32").declareVariables(...inputVars, output)}

            ${shaderHelper.mainStart()}
            ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}
            var outputIndices = ${output.offsetToIndices("global_idx")};
            ${inputVars.map((_var, i) => `var input${i}Indices: ${inputVars[i].type.indices};`).join("\n")}
            ${reduceOps2.join("\n")};
            ${output.setByOffset("global_idx", "sum")};
          }`;
        };
        return {
          name: "Einsum",
          shaderCache: { hint: einsumEquation.equation, inputDependencies: inputShapes.map(() => "rank") },
          getRunData: () => {
            const programUniformsInit = uniformsSymbols.filter((symbol) => einsumEquation.symbolToInfo.has(symbol)).map((symbol) => ({ type: 12 /* uint32 */, data: einsumEquation.symbolToInfo.get(symbol)?.dimValue || 0 }));
            programUniformsInit.push({ type: 12 /* uint32 */, data: outputSize });
            const programUniforms = inputShapes.map((dims, _) => [...createTensorShapeVariables(dims)]).reduce((acc, inputProgramUniforms) => acc.concat(inputProgramUniforms), programUniformsInit);
            programUniforms.push(...createTensorShapeVariables(outputShape));
            return {
              outputs: [{ dims: outputShape, dataType }],
              dispatchGroup: { x: Math.ceil(
                outputSize / 64
                /* workgroup size */
              ) },
              programUniforms
            };
          },
          getShaderSource
        };
      };
      einsum = (context, attributes) => {
        const einsumEquation = new EinsumEquation(context.inputs, attributes.equation);
        const outputShape = einsumEquation.outputDims;
        const inputShapes = context.inputs.map((input, _) => input.dims);
        context.compute(createEinsumProgramInfo(inputShapes, context.inputs[0].dataType, einsumEquation, outputShape));
      };
      parseEinsumAttributes = (attributes) => {
        const equation = attributes.equation.replace(/\s+/g, "");
        return createAttributeWithCacheKey({ equation });
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/expand.ts
  var validateInputs11, getAdjustedShape, calculateOutputShape2, createExpandProgramInfo, expand;
  var init_expand = __esm({
    "web/lib/wasm/jsep/webgpu/ops/expand.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_common();
      validateInputs11 = (inputs) => {
        if (!inputs || inputs.length !== 2) {
          throw new Error("Expand requires 2 input.");
        }
        const inputShape = inputs[0].dims;
        const shape = Array.from(inputs[1].getBigInt64Array(), Number);
        let shapeIndex = shape.length < inputShape.length ? 0 : shape.length - inputShape.length;
        let inputShapeIndex = inputShape.length < shape.length ? 0 : inputShape.length - shape.length;
        for (; shapeIndex < shape.length && inputShapeIndex < inputShape.length; ++shapeIndex, ++inputShapeIndex) {
          if (shape[shapeIndex] !== inputShape[inputShapeIndex] && shape[shapeIndex] !== 1 && inputShape[inputShapeIndex] !== 1) {
            throw new Error("Expand requires shape to be broadcastable to input");
          }
        }
      };
      getAdjustedShape = (shape1, shape2) => {
        const diff = shape1.length - shape2.length;
        const shape = [];
        for (let i = 0; i < diff; ++i) {
          shape.push(shape1[i]);
        }
        for (let i = 0; i < shape2.length; ++i) {
          shape.push(shape2[i] === 1 ? shape1[i + diff] : shape2[i]);
        }
        return shape;
      };
      calculateOutputShape2 = (inputShape, shape) => inputShape.length > shape.length ? getAdjustedShape(inputShape, shape) : getAdjustedShape(shape, inputShape);
      createExpandProgramInfo = (inputs) => {
        const inputShape = inputs[0].dims;
        const shape = Array.from(inputs[1].getBigInt64Array(), Number);
        const outputShape = calculateOutputShape2(inputShape, shape);
        const dataType = inputs[0].dataType;
        const isBoolOrScalar = dataType === 9 /* bool */ || ShapeUtil.size(inputShape) === 1;
        const iComponents = dataType === 9 /* bool */ ? 4 : inputShape.length > 0 && inputShape[inputShape.length - 1] % 4 === 0 ? 4 : 1;
        const components = isBoolOrScalar ? 4 : outputShape.length > 0 && outputShape[outputShape.length - 1] % 4 === 0 ? 4 : 1;
        const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components);
        const getShaderSource = (shaderHelper) => {
          const input = inputVariable("input", dataType, inputShape.length, iComponents);
          const output = outputVariable("output", dataType, outputShape.length, components);
          let assignment;
          if (dataType === 9 /* bool */) {
            const singleAssignment = (resStr, x, typeCast = "") => `
          let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)};
          let offset${x} = ${input.broadcastedIndicesToOffset(`outputIndices${x}`, output)};
          let index${x} = offset${x} / 4u;
          let component${x} = offset${x} % 4u;
          ${resStr}[${x}] = ${typeCast}(${input.getByOffset(`index${x}`)}[component${x}]);
        `;
            assignment = `
        let outputOffset = global_idx * ${components};
        var data = vec4<u32>(0);
        ${singleAssignment("data", 0, "u32")}
        ${singleAssignment("data", 1, "u32")}
        ${singleAssignment("data", 2, "u32")}
        ${singleAssignment("data", 3, "u32")}
        ${output.setByOffset("global_idx", "data")}
      }`;
          } else {
            assignment = `
        let outputIndices = ${output.offsetToIndices(`global_idx * ${components}`)};
        let inputOffset = ${input.broadcastedIndicesToOffset("outputIndices", output)};
        let data = ${output.type.value}(${input.getByOffset(`inputOffset / ${iComponents}`)});
        ${output.setByOffset("global_idx", "data")}
      }`;
          }
          return `
    ${shaderHelper.registerUniform("vec_size", "u32").declareVariables(input, output)}
    ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.vec_size")}
    ${assignment}`;
        };
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          ...createTensorShapeVariables(inputShape, outputShape)
        ];
        return {
          name: "Expand",
          shaderCache: { hint: `${outputShape.length};${iComponents}${components}`, inputDependencies: ["rank"] },
          getShaderSource,
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms
          })
        };
      };
      expand = (context) => {
        validateInputs11(context.inputs);
        context.compute(createExpandProgramInfo(context.inputs), { inputs: [0] });
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/fast-gelu.ts
  var createFastGeluProgramInfo, fastGelu2;
  var init_fast_gelu = __esm({
    "web/lib/wasm/jsep/webgpu/ops/fast-gelu.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_common();
      init_unary_op();
      createFastGeluProgramInfo = (inputTensors) => {
        const dataType = inputTensors[0].dataType;
        const outputSize = ShapeUtil.size(inputTensors[0].dims);
        const biasLength = ShapeUtil.size(inputTensors[1].dims);
        const useVec4 = biasLength % 4 === 0;
        const getShaderSource = (shaderHelper) => {
          const x = inputVariable("x", dataType, [1], 4);
          const bias = inputVariable("bias", dataType, [1], 4);
          const y = outputVariable("y", dataType, [1], 4);
          const uniforms = [
            { name: "output_vec_size", type: "u32" },
            { name: "bias_size", type: "u32" }
          ];
          const singleElementBias = (i) => `
      let bias${i}_offset: u32 = (global_idx * 4 + ${i}) % uniforms.bias_size;
      let bias${i} = ${bias.getByOffset(`bias${i}_offset / 4`)}[bias${i}_offset % 4];`;
          const biasGetExpression = useVec4 ? `
      let bias = ${bias.getByOffset("global_idx % (uniforms.bias_size / 4)")};` : `${singleElementBias(0)}${singleElementBias(1)}${singleElementBias(2)}${singleElementBias(3)}
      let bias = ${x.type.value}(bias0, bias1, bias2, bias3);`;
          return `${shaderHelper.registerUniforms(uniforms).declareVariables(x, bias, y)}

    ${fastGeluImpl(tensorTypeToWsglValueType(dataType))}

    ${shaderHelper.mainStart(WORKGROUP_SIZE)}
      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_vec_size")}

      let x = ${x.getByOffset("global_idx")};
      ${biasGetExpression}
      let x_in = x + bias;
      ${y.setByOffset("global_idx", fastGeluExpression("x_in"))}
    }`;
        };
        return {
          name: "FastGeluWithBias",
          shaderCache: { hint: `${useVec4}`, inputDependencies: ["type", "type"] },
          getShaderSource,
          getRunData: (inputs) => ({
            outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }],
            programUniforms: [
              { type: 12 /* uint32 */, data: Math.ceil(outputSize / 4) },
              { type: 12 /* uint32 */, data: biasLength }
            ],
            dispatchGroup: { x: Math.ceil(outputSize / WORKGROUP_SIZE / 4) }
          })
        };
      };
      fastGelu2 = (context) => {
        if (context.inputs.length < 2 || ShapeUtil.size(context.inputs[1].dims) === 0) {
          fastGelu(context);
        } else {
          context.compute(createFastGeluProgramInfo(context.inputs));
        }
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/gather.ts
  var validateInputs12, createGatherProgramInfo, parseGatherAttributes, gather;
  var init_gather = __esm({
    "web/lib/wasm/jsep/webgpu/ops/gather.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      validateInputs12 = (inputs) => {
        if (!inputs || inputs.length !== 2) {
          throw new Error("Gather requires 2 inputs.");
        }
      };
      createGatherProgramInfo = (inputs, attributes) => {
        const inputShape = inputs[0].dims;
        const indicesShape = inputs[1].dims;
        const inputRank = inputShape.length;
        const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);
        const outputShape = inputShape.slice(0);
        outputShape.splice(axis, 1, ...indicesShape);
        const axisDimLimit = inputShape[axis];
        const components = inputs[0].dataType === 9 /* bool */ ? 4 : 1;
        const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components);
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 6 /* int32 */, data: axisDimLimit },
          { type: 12 /* uint32 */, data: axis },
          ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, outputShape)
        ];
        const getShaderSource = (shaderHelper) => {
          const data = inputVariable("data", inputs[0].dataType, inputs[0].dims.length, components);
          const indices = inputVariable("inputIndices", inputs[1].dataType, inputs[1].dims.length);
          const output = outputVariable("output", inputs[0].dataType, outputShape.length, components);
          const calcDataIndices = (x) => {
            const indicesRank = indicesShape.length;
            let calcStr = `var indicesIndices${x}  = ${indices.type.indices}(0);`;
            for (let i = 0; i < indicesRank; i++) {
              calcStr += `${indicesRank > 1 ? `indicesIndices${x}[${i}]` : `indicesIndices${x}`} = ${outputShape.length > 1 ? `outputIndices${x}[uniforms.axis + ${i}]` : `outputIndices${x}`};`;
            }
            calcStr += `
          var idx${x} = ${indices.getByIndices(`indicesIndices${x}`)};
          if (idx${x} < 0) {
            idx${x} = idx${x} + uniforms.axisDimLimit;
          }
          var dataIndices${x} : ${data.type.indices};
        `;
            for (let i = 0, j = 0; i < inputRank; i++) {
              if (i === axis) {
                calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = u32(idx${x});`;
                j += indicesRank;
              } else {
                calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = ${outputShape.length > 1 ? `outputIndices${x}[${j}]` : `outputIndices${x}`};`;
                j++;
              }
            }
            return calcStr;
          };
          let assignment;
          if (inputs[0].dataType === 9 /* bool */) {
            const singleAssignment = (resStr, x, typeCast = "") => `
          let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)};
          ${calcDataIndices(x)};
          let offset${x} = ${data.indicesToOffset(`dataIndices${x}`)};
          let index${x} = offset${x} / 4u;
          let component${x} = offset${x} % 4u;
          ${resStr}[${x}] = ${typeCast}(${data.getByOffset(`index${x}`)}[component${x}]);
        `;
            assignment = `
        let outputOffset = global_idx * ${components};
        var value = vec4<u32>(0);
        ${singleAssignment("value", 0, "u32")}
        ${singleAssignment("value", 1, "u32")}
        ${singleAssignment("value", 2, "u32")}
        ${singleAssignment("value", 3, "u32")}
        ${output.setByOffset("global_idx", "value")}
      `;
          } else {
            assignment = `
      let outputIndices = ${output.offsetToIndices("global_idx")};
      ${calcDataIndices("")};
      let value = ${data.getByIndices("dataIndices")};
      ${output.setByOffset("global_idx", "value")};
      `;
          }
          return `
      ${shaderHelper.registerUniform("outputSize", "u32").registerUniform("axisDimLimit", "i32").registerUniform("axis", "u32").declareVariables(data, indices, output)}
      ${shaderHelper.mainStart()}
        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}
        ${assignment}
      }`;
        };
        return {
          name: "Gather",
          shaderCache: { hint: attributes.cacheKey, inputDependencies: ["rank", "rank"] },
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms
          }),
          getShaderSource
        };
      };
      parseGatherAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis });
      gather = (context, attributes) => {
        const inputs = context.inputs;
        validateInputs12(inputs);
        context.compute(createGatherProgramInfo(context.inputs, attributes));
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/gather-nd.ts
  var computeSliceOffsets, gatherND, parseGatherNDAttributes;
  var init_gather_nd = __esm({
    "web/lib/wasm/jsep/webgpu/ops/gather-nd.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_common();
      computeSliceOffsets = (context, indicesData, sizesFromSliceDimsData, batchDims, inputDims, numSlices, numSlicesPerBatch, inputBatchStride, numSliceDims) => {
        const programUniforms = [
          { type: 12 /* uint32 */, data: numSlices },
          { type: 12 /* uint32 */, data: batchDims },
          { type: 12 /* uint32 */, data: inputDims },
          { type: 12 /* uint32 */, data: sizesFromSliceDimsData },
          { type: 12 /* uint32 */, data: numSlicesPerBatch },
          { type: 12 /* uint32 */, data: inputBatchStride },
          { type: 12 /* uint32 */, data: numSliceDims }
        ];
        const outputShape = [numSlices];
        programUniforms.push(...createTensorShapeVariables(indicesData.dims, outputShape));
        const getShaderSource = (shaderHelper) => {
          const indices = inputVariable("indices_data", indicesData.dataType, indicesData.dims.length);
          const output = outputVariable("input_slice_offsets_data", 12 /* uint32 */, 1, 1);
          const variables = [indices, output];
          const uniforms = [
            { name: "output_size", type: "u32" },
            { name: "batch_dims", type: "u32" },
            { name: "input_dims", type: "u32", length: inputDims.length },
            { name: "sizes_from_slice_dims_data", type: "u32", length: sizesFromSliceDimsData.length },
            { name: "num_slices_per_batch", type: "u32" },
            { name: "input_batch_stride", type: "u32" },
            { name: "num_slice_dims", type: "u32" }
          ];
          return `
  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}
  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
    let batch_idx = global_idx / uniforms.num_slices_per_batch;
    let base_offset = batch_idx * uniforms.input_batch_stride;

    let slice_indices_base_offset = global_idx * uniforms.num_slice_dims;
    var relative_slice_offset = 0;
    for (var dim_idx = 0u; dim_idx < uniforms.num_slice_dims; dim_idx ++) {
      var index = i32(indices_data[dim_idx + slice_indices_base_offset].x);
      let input_dim_idx = uniforms.batch_dims + dim_idx;
      if (index < 0) {
        ${inputDims.length === 1 ? "index += i32(uniforms.input_dims);" : "index += i32(uniforms.input_dims[input_dim_idx]);"}
      }
      ${sizesFromSliceDimsData.length === 1 ? "relative_slice_offset += index * i32(uniforms.sizes_from_slice_dims_data);" : "relative_slice_offset += index * i32(uniforms.sizes_from_slice_dims_data[dim_idx]);"}
    }

    input_slice_offsets_data[global_idx] =  base_offset + u32(relative_slice_offset);
  }`;
        };
        return context.compute(
          {
            name: "computeSliceOffsets",
            shaderCache: { hint: `${inputDims.length}_${sizesFromSliceDimsData.length}`, inputDependencies: ["rank"] },
            getRunData: () => ({
              outputs: [{ dims: outputShape, dataType: context.inputs[1].dataType }],
              dispatchGroup: { x: Math.ceil(numSlices / 64) },
              programUniforms
            }),
            getShaderSource
          },
          { inputs: [indicesData], outputs: [-1] }
        )[0];
      };
      gatherND = (context, attributes) => {
        const inputs = context.inputs;
        const inputShape = inputs[0].dims;
        const inputType = inputs[0].dataType;
        const indicesShape = inputs[1].dims;
        const numSliceDims = indicesShape[indicesShape.length - 1];
        const numSlices = ShapeUtil.sizeToDimension(indicesShape, indicesShape.length - 1);
        const sliceSize = ShapeUtil.sizeFromDimension(inputShape, attributes.batchDims + numSliceDims);
        const numBatches = ShapeUtil.sizeToDimension(inputShape, attributes.batchDims);
        const inputBatchStride = ShapeUtil.sizeFromDimension(inputShape, attributes.batchDims);
        const numSlicesPerBatch = numSlices / numBatches;
        const sizesFromSliceDims = new Array(numSliceDims);
        let runningProduct = sliceSize;
        for (let i = 0; i < numSliceDims; ++i) {
          sizesFromSliceDims[numSliceDims - 1 - i] = runningProduct;
          runningProduct *= inputShape[attributes.batchDims + numSliceDims - 1 - i];
        }
        const inputSliceOffsets = computeSliceOffsets(
          context,
          inputs[1],
          sizesFromSliceDims,
          attributes.batchDims,
          inputShape,
          numSlices,
          numSlicesPerBatch,
          inputBatchStride,
          numSliceDims
        );
        const lastIndicesDimension = attributes.batchDims + numSliceDims;
        if (lastIndicesDimension > inputShape.length) {
          throw new Error("last dimension of indices must not be larger than rank of input tensor");
        }
        const outputShape = indicesShape.slice(0, -1).concat(inputShape.slice(lastIndicesDimension));
        const outputSize = ShapeUtil.size(outputShape);
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 12 /* uint32 */, data: sliceSize },
          ...createTensorShapeVariables(inputs[0].dims, inputSliceOffsets.dims, outputShape)
        ];
        const getShaderSource = (shaderHelper) => {
          const input = inputVariable("data", inputs[0].dataType, inputs[0].dims.length);
          const indices = inputVariable("slice_offsets", 12 /* uint32 */, inputSliceOffsets.dims.length);
          const output = outputVariable("output", inputs[0].dataType, outputShape.length);
          return `
          ${shaderHelper.registerUniform("output_size", "u32").registerUniform("slice_size", "u32").declareVariables(input, indices, output)}
            ${shaderHelper.mainStart()}
            ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
          let slice_offset = slice_offsets[global_idx / uniforms.slice_size];
          output[global_idx] = data[u32(slice_offset) + global_idx % uniforms.slice_size];
        }`;
        };
        context.compute(
          {
            name: "GatherND",
            shaderCache: { hint: attributes.cacheKey, inputDependencies: ["rank", "rank"] },
            getRunData: () => ({
              outputs: [{ dims: outputShape, dataType: inputType }],
              dispatchGroup: { x: Math.ceil(
                outputSize / 64
                /* workgroup size */
              ) },
              programUniforms
            }),
            getShaderSource
          },
          { inputs: [inputs[0], inputSliceOffsets] }
        );
      };
      parseGatherNDAttributes = (attributes) => {
        const batchDims = attributes.batch_dims;
        return {
          batchDims,
          cacheKey: ""
        };
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/gather-block-quantized.ts
  var validateInputs13, createGatherBlockQuantizedProgramInfo, gatherBlockQuantized, parseGatherBlockQuantizedAttributes;
  var init_gather_block_quantized = __esm({
    "web/lib/wasm/jsep/webgpu/ops/gather-block-quantized.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      validateInputs13 = (inputs, attributes) => {
        if (inputs.length < 3 || inputs.length > 4) {
          throw new Error("GatherBlockQuantized requires 3 or 4 inputs.");
        }
        const quantizeAxis = ShapeUtil.normalizeAxis(attributes.quantizeAxis, inputs[0].dims.length);
        const blockSize = attributes.blockSize;
        const data = inputs[0];
        const scales = inputs[2];
        const zeroPoint = inputs.length === 4 ? inputs[3] : void 0;
        if (scales.dims.length !== data.dims.length || !data.dims.map((d, i) => i === quantizeAxis ? Math.ceil(d / blockSize) === scales.dims[i] : d === scales.dims[i]).reduce((a, b) => a && b, true)) {
          throw new Error(
            "Scales must have the same rank as the input tensor and the dims should match except on gatherAxis."
          );
        }
        if (zeroPoint) {
          if (zeroPoint.dataType !== data.dataType) {
            throw new Error("Zero point must have the same data type as the input tensor.");
          }
          if (zeroPoint.dims.length !== scales.dims.length || !zeroPoint.dims.map((d, i) => d === scales.dims[i]).reduce((a, b) => a && b, true)) {
            throw new Error(
              "Zero point must have the same rank as the input tensor and the dims should match except on quantizeAxis."
            );
          }
        }
      };
      createGatherBlockQuantizedProgramInfo = (inputs, attributes) => {
        const inputShape = inputs[0].dims;
        const indicesShape = inputs[1].dims;
        const inputRank = inputShape.length;
        const gatherAxis = ShapeUtil.normalizeAxis(attributes.gatherAxis, inputRank);
        const quantizeAxis = ShapeUtil.normalizeAxis(attributes.quantizeAxis, inputRank);
        const outputShape = inputShape.slice(0);
        outputShape.splice(gatherAxis, 1, ...indicesShape);
        const outputSize = ShapeUtil.size(outputShape);
        const outputType = inputs[2].dataType;
        const inputType = inputs[0].dataType;
        const isSigned = inputType === 22 /* int4 */;
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 12 /* uint32 */, data: quantizeAxis },
          { type: 12 /* uint32 */, data: gatherAxis },
          { type: 12 /* uint32 */, data: attributes.blockSize },
          ...createTensorShapeVariables(...inputs.map((input, _) => input.dims), outputShape)
        ];
        const getShaderSource = (shaderHelper) => {
          const data = inputVariable("data", inputs[0].dataType, inputs[0].dims.length);
          const indices = inputVariable("inputIndices", inputs[1].dataType, inputs[1].dims.length);
          const scales = inputVariable("scales", inputs[2].dataType, inputs[2].dims.length);
          const zeroPoint = inputs.length > 3 ? inputVariable("zeroPoint", inputs[3].dataType, inputs[3].dims.length) : void 0;
          const output = outputVariable("output", outputType, outputShape.length);
          const inputVariables = [data, indices, scales];
          if (zeroPoint) {
            inputVariables.push(zeroPoint);
          }
          const uniforms = [
            { name: "output_size", type: "u32" },
            { name: "quantize_axis", type: "u32" },
            { name: "gather_axis", type: "u32" },
            { name: "block_size", type: "u32" }
          ];
          return `
        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}
        ${shaderHelper.mainStart()}
        let output_indices = ${output.offsetToIndices("global_idx")};
        var indices_indices = ${indices.type.indices}(0);
        ${(() => {
            if (indicesShape.length > 1) {
              return `
          for (var i: u32 = 0; i < ${indicesShape.length}; i++) {
            let index = ${output.indicesGet("output_indices", "uniforms.gather_axis + i")};
            ${indices.indicesSet("indices_indices", "i", "index")};
          }`;
            } else {
              return `indices_indices = ${output.indicesGet("output_indices", "uniforms.gather_axis")};`;
            }
          })()};
        var data_indices = ${data.type.indices}(0);
        for (var i: u32 = 0; i < uniforms.gather_axis; i++) {
          let index = ${output.indicesGet("output_indices", "i")};
          ${data.indicesSet("data_indices", "i", "index")};
        }
        var index_from_indices = ${indices.getByIndices("indices_indices")};
        if (index_from_indices < 0) {
          index_from_indices += ${inputShape[gatherAxis]};
        }
        ${data.indicesSet("data_indices", "uniforms.gather_axis", "u32(index_from_indices)")};
        for (var i = uniforms.gather_axis + 1; i < ${outputShape.length}; i++) {
          let index = ${output.indicesGet("output_indices", `i + ${indicesShape.length} - 1`)};
          ${data.indicesSet("data_indices", "i", "index")};
        }
        let data_offset = ${data.indicesToOffset("data_indices")};
        let data_index = data_offset % 8;
        // Convert 4-bit packed data to 8-bit packed data.
        let packed_4bit_quantized_data = ${data.getByOffset("data_offset / 8")};
        let packed_8bit_quantized_data = (packed_4bit_quantized_data >> (4 * (data_index % 2))) & 0x0f0f0f0f;
        let quantized_data_vec = ${isSigned ? "unpack4xI8" : "unpack4xU8"}(u32(packed_8bit_quantized_data));
        let quantized_data = quantized_data_vec[data_index / 2];
        var scale_indices = data_indices;
        let quantize_axis_index = ${scales.indicesGet("data_indices", "uniforms.quantize_axis")} / uniforms.block_size;
        ${scales.indicesSet("scale_indices", "uniforms.quantize_axis", "quantize_axis_index")};
        var scale = ${scales.getByIndices("scale_indices")};
        ${(() => {
            if (!zeroPoint) {
              return "var zero_point = 0";
            } else {
              return `
              let zero_point_indices = scale_indices;
              let zero_point_offset = ${zeroPoint.indicesToOffset("zero_point_indices")};
              let zero_point_index = zero_point_offset % 8;
              let packed_4bit_zero_points = ${zeroPoint.getByOffset("zero_point_offset / 8")};
              let packed_8bit_zero_points = (packed_4bit_zero_points >> (4 * (zero_point_index % 2))) & 0x0f0f0f0f;
              let zero_point_vec = ${isSigned ? "unpack4xI8" : "unpack4xU8"}(u32(packed_8bit_zero_points));
              let zero_point = zero_point_vec[zero_point_index / 2];`;
            }
          })()};
        let dequantized_data = ${tensorTypeToWsglValueType(outputType)}(quantized_data - zero_point) * scale;
        ${output.setByOffset("global_idx", "dequantized_data")};
    }`;
        };
        return {
          name: "GatherBlockQuantized",
          shaderCache: {
            hint: `${attributes.cacheKey};${inputs.filter((_, i) => i !== 1).map((input) => input.dims.join("_")).join(";")}`,
            inputDependencies: Array.from({ length: inputs.length }, (_v, _i) => "rank")
          },
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: outputType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms
          }),
          getShaderSource
        };
      };
      gatherBlockQuantized = (context, attributes) => {
        const inputs = context.inputs;
        validateInputs13(inputs, attributes);
        context.compute(createGatherBlockQuantizedProgramInfo(context.inputs, attributes));
      };
      parseGatherBlockQuantizedAttributes = (attributes) => createAttributeWithCacheKey({
        blockSize: attributes.blockSize,
        gatherAxis: attributes.gatherAxis,
        quantizeAxis: attributes.quantizeAxis
      });
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/gather-elements.ts
  var validateInputs14, createGatherElementsProgramInfo, parseGatherElementsAttributes, gatherElements;
  var init_gather_elements = __esm({
    "web/lib/wasm/jsep/webgpu/ops/gather-elements.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      validateInputs14 = (inputs) => {
        if (!inputs || inputs.length !== 2) {
          throw new Error("GatherElements requires 2 inputs.");
        }
        if (inputs[0].dims.length < 1) {
          throw new Error("GatherElements requires that the data input be rank >= 1.");
        }
        if (inputs[0].dims.length !== inputs[1].dims.length) {
          throw new Error(`GatherElements requires that the data input and
                     indices input tensors be of same rank.`);
        }
      };
      createGatherElementsProgramInfo = (inputs, attributes) => {
        const inputShape = inputs[0].dims;
        const inputOutputDataType = inputs[0].dataType;
        const inputRank = inputShape.length;
        const indicesShape = inputs[1].dims;
        const indicesDataType = inputs[1].dataType;
        const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);
        const axisDimLimit = inputShape[axis];
        const outputShape = indicesShape.slice(0);
        const outputSize = ShapeUtil.size(outputShape);
        const input = inputVariable("input", inputOutputDataType, inputRank);
        const indices = inputVariable("indicesInput", indicesDataType, indicesShape.length);
        const output = outputVariable("output", inputOutputDataType, outputShape.length);
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 6 /* int32 */, data: axisDimLimit },
          { type: 12 /* uint32 */, data: axis }
        ];
        programUniforms.push(...createTensorShapeVariables(inputShape, indicesShape, outputShape));
        const inputDependencies = ["rank", "rank"];
        const getShaderSource = (shaderHelper) => `
      ${shaderHelper.registerUniform("outputSize", "u32").registerUniform("axisDimLimit", "i32").registerUniform("axis", "u32").declareVariables(input, indices, output)}
      ${shaderHelper.mainStart()}
      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}

      let outputIndices = ${output.offsetToIndices("global_idx")};

      var idx = ${indices.getByOffset("global_idx")};
      if (idx < 0) {
        idx = idx + uniforms.axisDimLimit;
      }
      var inputIndices = ${input.type.indices}(outputIndices);
      ${input.indicesSet("inputIndices", "uniforms.axis", "u32(idx)")};
      let value = ${input.getByIndices("inputIndices")};

      ${output.setByOffset("global_idx", "value")};
  }`;
        return {
          name: "GatherElements",
          shaderCache: { inputDependencies },
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms
          }),
          getShaderSource
        };
      };
      parseGatherElementsAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis });
      gatherElements = (context, attributes) => {
        const inputs = context.inputs;
        validateInputs14(inputs);
        context.compute(createGatherElementsProgramInfo(context.inputs, attributes));
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/gemm.ts
  var validateInputs15, createGemmProgramInfo, parseGemmAttributes, gemm;
  var init_gemm = __esm({
    "web/lib/wasm/jsep/webgpu/ops/gemm.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_common();
      validateInputs15 = (inputs) => {
        if (!inputs) {
          throw new Error("Input is missing");
        }
        if (inputs.length < 2 || inputs.length > 3) {
          throw new Error("Invaid input number.");
        }
        if (inputs.length === 3 && inputs[2].dims.length > 2) {
          throw new Error("Invalid input shape of C");
        }
        if (inputs[0].dataType !== inputs[1].dataType || inputs.length === 3 && inputs[0].dataType !== inputs[2].dataType) {
          throw new Error("Input types are mismatched");
        }
      };
      createGemmProgramInfo = (inputs, attributes) => {
        const aShape = inputs[0].dims.slice();
        const bShape = inputs[1].dims.slice();
        const [M, N, K] = 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");
        }
        const tileSize = 16;
        const numTileN = Math.ceil(N / tileSize);
        const numTileM = Math.ceil(M / tileSize);
        const useShared = true;
        const outputSize = ShapeUtil.size(outputShape);
        const programUniforms = [
          { type: 12 /* uint32 */, data: useShared ? numTileN : outputSize },
          { type: 12 /* uint32 */, data: M },
          { type: 12 /* uint32 */, data: N },
          { type: 12 /* uint32 */, data: K },
          { type: 1 /* float */, data: attributes.alpha },
          { type: 1 /* float */, data: attributes.beta }
        ];
        const inputDependencies = ["type", "type"];
        if (inputs.length === 3) {
          programUniforms.push(...createTensorShapeVariables(inputs[2].dims));
          inputDependencies.push("rank");
        }
        programUniforms.push(...createTensorShapeVariables(outputShape));
        const getShaderSource = (shaderHelper) => {
          let line = "";
          if (attributes.transA && attributes.transB) {
            line = "value += a[k * uniforms.M + m] * b[n * uniforms.K + k];";
          } else if (attributes.transA && !attributes.transB) {
            line = "value += a[k * uniforms.M + m] * b[k * uniforms.N + n];";
          } else if (!attributes.transA && attributes.transB) {
            line = "value += a[m * uniforms.K + k] * b[n * uniforms.K + k];";
          } else if (!attributes.transA && !attributes.transB) {
            line = "value += a[m * uniforms.K + k] * b[k * uniforms.N + n];";
          }
          const calculateAlpha = attributes.alpha === 1 ? "" : "value *= uniforms.alpha;";
          const a = inputVariable("a", inputs[0].dataType, inputs[0].dims);
          const b = inputVariable("b", inputs[1].dataType, inputs[1].dims);
          const dataType = a.type.value;
          let c = null;
          const variables = [a, b];
          if (inputs.length === 3) {
            c = inputVariable("c", inputs[2].dataType, inputs[2].dims.length);
            variables.push(c);
          }
          const output = outputVariable("output", inputs[0].dataType, outputShape.length);
          variables.push(output);
          const uniforms = [
            { name: "output_size", type: "u32" },
            { name: "M", type: "u32" },
            { name: "N", type: "u32" },
            { name: "K", type: "u32" },
            { name: "alpha", type: "f32" },
            { name: "beta", type: "f32" }
          ];
          return `
  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}

  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}

    let m = global_idx / uniforms.N;
    let n = global_idx % uniforms.N;

    var value = ${dataType}(0);
    for (var k: u32 = 0u; k < uniforms.K; k++) {
      ${line}
    }

    ${calculateAlpha}
    ${(() => {
            if (c != null) {
              return `let cOffset = ${c.broadcastedIndicesToOffset("vec2(m, n)", output)}; value += ${dataType}(uniforms.beta) * ${c.getByOffset("cOffset")};`;
            }
            return "";
          })()}
    output[global_idx] = value;
  }`;
        };
        const getShaderSourceShared = (shaderHelper) => {
          const a = inputVariable("a", inputs[0].dataType, inputs[0].dims);
          const b = inputVariable("b", inputs[1].dataType, inputs[1].dims);
          let c = null;
          const variables = [a, b];
          if (inputs.length === 3) {
            c = inputVariable("c", inputs[2].dataType, inputs[2].dims.length);
            variables.push(c);
          }
          const output = outputVariable("output", inputs[0].dataType, outputShape.length);
          variables.push(output);
          const uniforms = [
            { name: "num_tile_n", type: "u32" },
            { name: "M", type: "u32" },
            { name: "N", type: "u32" },
            { name: "K", type: "u32" },
            { name: "alpha", type: "f32" },
            { name: "beta", type: "f32" }
          ];
          let calcResult = "";
          let fillWorkgroupMemory = "";
          if (attributes.transA && attributes.transB) {
            fillWorkgroupMemory = `
      var col = tile_row_start + local_id.x;
      var row = k_start + local_id.y;
      if (col < uniforms.M && row < uniforms.K) {
        tile_a[local_id.y][local_id.x] = a[row * uniforms.M + col];
      } else {
        tile_a[local_id.y][local_id.x] = ${a.type.value}(0);
      }

      col = k_start + local_id.x;
      row = tile_col_start + local_id.y;
      if (col < uniforms.K && row < uniforms.N) {
        tile_b[local_id.y][local_id.x] = b[row * uniforms.K + col];
      } else {
        tile_b[local_id.y][local_id.x] = ${b.type.value}(0);
      }
      `;
            calcResult = `value += tile_a[k][local_id.y] * tile_b[local_id.x][k];`;
          } else if (attributes.transA && !attributes.transB) {
            fillWorkgroupMemory = `
      var col = tile_row_start + local_id.x;
      var row = k_start + local_id.y;
      if (col < uniforms.M && row < uniforms.K) {
        tile_a[local_id.y][local_id.x] = a[row * uniforms.M + col];
      } else {
        tile_a[local_id.y][local_id.x] = ${a.type.value}(0);
      }

      col = tile_col_start + local_id.x;
      row = k_start + local_id.y;
      if (col < uniforms.N && row < uniforms.K) {
        tile_b[local_id.y][local_id.x] = b[row * uniforms.N + col];
      } else {
        tile_b[local_id.y][local_id.x] = ${b.type.value}(0);
      }
      `;
            calcResult = `value += tile_a[k][local_id.y] * tile_b[k][local_id.x];`;
          } else if (!attributes.transA && attributes.transB) {
            fillWorkgroupMemory = `
      var col = k_start + local_id.x;
      var row = tile_row_start + local_id.y;
      if (col < uniforms.K && row < uniforms.M) {
        tile_a[local_id.y][local_id.x] = a[row * uniforms.K + col];
      } else {
        tile_a[local_id.y][local_id.x] = ${a.type.value}(0);
      }

      col = k_start + local_id.x;
      row = tile_col_start + local_id.y;
      if (col < uniforms.K && row < uniforms.N) {
        tile_b[local_id.y][local_id.x] = b[row * uniforms.K + col];
      } else {
        tile_b[local_id.y][local_id.x] = ${b.type.value}(0);
      }
      `;
            calcResult = `value += tile_a[local_id.y][k] * tile_b[local_id.x][k];`;
          } else if (!attributes.transA && !attributes.transB) {
            fillWorkgroupMemory = `
      var col = k_start + local_id.x;
      var row = tile_row_start + local_id.y;
      if (col < uniforms.K && row < uniforms.M) {
        tile_a[local_id.y][local_id.x] = a[row * uniforms.K + col];
      } else {
        tile_a[local_id.y][local_id.x] = ${a.type.value}(0);
      }

      col = tile_col_start + local_id.x;
      row = k_start + local_id.y;
      if (col < uniforms.N && row < uniforms.K) {
        tile_b[local_id.y][local_id.x] = b[row * uniforms.N + col];
      } else {
        tile_b[local_id.y][local_id.x] = ${b.type.value}(0);
      }
      `;
            calcResult = `value += tile_a[local_id.y][k] * tile_b[k][local_id.x];`;
          }
          const calculateAlpha = attributes.alpha === 1 ? "" : "value *= uniforms.alpha;";
          return `
  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}
  var<workgroup> tile_a: array<array<${a.type.storage}, ${tileSize}>, ${tileSize}>;
  var<workgroup> tile_b: array<array<${b.type.storage}, ${tileSize}>, ${tileSize}>;
  ${shaderHelper.mainStart([tileSize, tileSize, 1])}
    let tile_col_start = (workgroup_index % uniforms.num_tile_n) * ${tileSize};
    let tile_row_start = (workgroup_index / uniforms.num_tile_n) * ${tileSize};
    let num_tiles = (uniforms.K - 1) / ${tileSize} + 1;
    var k_start = 0u;
    var value = ${output.type.value}(0);
    for (var t: u32 = 0u; t < num_tiles; t++) {
      ${fillWorkgroupMemory}
      k_start = k_start + ${tileSize};
      workgroupBarrier();

      for (var k: u32 = 0u; k < ${tileSize}; k++) {
        ${calcResult}
      }
      workgroupBarrier();
    }

    ${calculateAlpha}
    let m = tile_row_start + local_id.y;
    let n = tile_col_start + local_id.x;
    ${(() => {
            if (c != null) {
              return `let cOffset = ${c.broadcastedIndicesToOffset("vec2(m, n)", output)}; value += ${output.type.value}(uniforms.beta) * ${c.getByOffset("cOffset")};`;
            }
            return "";
          })()}
    if (m < uniforms.M && n < uniforms.N) {
      output[m * uniforms.N + n] = value;
    }
  }`;
        };
        if (useShared) {
          return {
            name: "GemmShared",
            shaderCache: { hint: `${attributes.cacheKey}`, inputDependencies },
            getRunData: () => ({
              outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],
              dispatchGroup: { x: numTileN * numTileM },
              programUniforms
            }),
            getShaderSource: getShaderSourceShared
          };
        }
        return {
          name: "Gemm",
          shaderCache: { hint: `${attributes.cacheKey}`, inputDependencies },
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms
          }),
          getShaderSource
        };
      };
      parseGemmAttributes = (attributes) => {
        const transA = attributes.transA;
        const transB = attributes.transB;
        const alpha = attributes.alpha;
        const beta = attributes.beta;
        return {
          transA,
          transB,
          alpha,
          beta,
          cacheKey: `${attributes.transA};${attributes.transB};${attributes.alpha === 1}`
        };
      };
      gemm = (context, attributes) => {
        validateInputs15(context.inputs);
        context.compute(createGemmProgramInfo(context.inputs, attributes));
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/grid-sample.ts
  var idxN, idxC, idxH, idxW, validateInputs16, gsGetCubicCoeffs, gsBicubicInterpolate, gsDenormalize, gsReflect, pixelAtGrid, computePixel, createGridSampleProgramInfo, gridSample, parseGridSampleAttributes;
  var init_grid_sample = __esm({
    "web/lib/wasm/jsep/webgpu/ops/grid-sample.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      [idxN, idxC, idxH, idxW] = [0, 1, 2, 3];
      validateInputs16 = (inputs) => {
        if (inputs[0].dims.length !== 4) {
          throw new Error("only 4-D tensor is supported.");
        }
        if (inputs[0].dims.length !== inputs[1].dims.length) {
          throw new Error("input dimensions must be equal to grid dimensions");
        }
        if (inputs[0].dims.length - 2 !== inputs[1].dims[inputs[1].dims.length - 1]) {
          throw new Error(`last dimension of grid must be equal to ${inputs[0].dims.length - 2}`);
        }
        if (inputs[0].dims[0] !== inputs[1].dims[0]) {
          throw new Error("grid batch size must match input batch size");
        }
      };
      gsGetCubicCoeffs = `
  fn gs_get_cubic_coeffs(x: f32) -> vec4<f32> {
    let cubic_alpha = -0.75f;
    let x_abs = abs(x);
    var coeffs: vec4<f32>;
    coeffs[0] = (((cubic_alpha * (x_abs + 1) - 5 * cubic_alpha) * (x_abs + 1) + 8 * cubic_alpha) * (x_abs + 1) - 4 * cubic_alpha);
    coeffs[1] = (((cubic_alpha + 2) * x_abs - (cubic_alpha + 3)) * x_abs * x_abs + 1);
    coeffs[2] = (((cubic_alpha + 2) * (1 - x_abs) - (cubic_alpha + 3)) * (1 - x_abs) * (1 - x_abs) + 1);
    coeffs[3] = (((cubic_alpha * (2 - x_abs) - 5 * cubic_alpha) * (2 - x_abs) + 8 * cubic_alpha) * (2 - x_abs) - 4 * cubic_alpha);
    return coeffs;
  }
`;
      gsBicubicInterpolate = (dataType) => `
  fn gs_bicubic_interpolate(p: mat4x4<${dataType}>, x: f32, y: f32) -> ${dataType} {
    var v: vec4<f32>;
    var coeffs = gs_get_cubic_coeffs(x);
    for (var i = 0; i < 4; i++) {
      v[i] = coeffs[0] * p[i][0] + coeffs[1] * p[i][1] + coeffs[2] * p[i][2] + coeffs[3] * p[i][3];
    }
    coeffs = gs_get_cubic_coeffs(y);
    let pixel = ${dataType}(coeffs[0] * v[0] + coeffs[1] * v[1] + coeffs[2] * v[2] + coeffs[3] * v[3]);
    return pixel;
  }
`;
      gsDenormalize = (attributes) => `
  fn gs_denormalize(n: f32, length: i32) -> f32 {
    ${attributes.alignCorners === 0 ? `
    // alignCorners: false => [-1, 1] to [-0.5, length - 0.5]
    return ((n + 1.0) * f32(length) - 1.0) / 2.0;
    ` : `
    // alignCorners: true => [-1, 1] to [0, length - 1]
    return (n + 1.0) / 2.0 * (f32(length - 1));
    `}
  }
`;
      gsReflect = (attributes) => `
  ${attributes.paddingMode === "reflection" ? `
      fn gs_reflect(x: i32, x_min: f32, x_max: f32) -> u32 {
        var dx = 0.0;
        var fx = f32(x);
        let range = x_max - x_min;
        if (fx < x_min) {
          dx = x_min - fx;
          let n = u32(dx / range);
          let r = dx - f32(n) * range;
          if (n % 2 == 0) {
            fx = x_min + r;
          } else {
            fx = x_max - r;
          }
        } else if (fx > x_max) {
          dx = fx - x_max;
          let n = u32(dx / range);
          let r = dx - f32(n) * range;
          if (n % 2 == 0) {
            fx = x_max - r;
          } else {
            fx = x_min + r;
          }
        }
        return u32(fx);
      }` : ""}
`;
      pixelAtGrid = (input, dataType, attributes) => `
  fn pixel_at_grid(r: i32, c: i32, H: i32, W: i32, batch: u32, channel: u32, border: vec4<f32>) -> ${dataType} {
     var pixel = ${dataType}(0);
     var indices = vec4<u32>(0);
     indices[${idxN}] = batch;
     indices[${idxC}] = channel;` + (() => {
        switch (attributes.paddingMode) {
          case "zeros":
            return `
          if (r >= 0 && r < H && c >=0 && c < W) {
            indices[${idxH}] = u32(r);
            indices[${idxW}] = u32(c);
          } else {
            return ${dataType}(0);
          }
        `;
          case "border":
            return `
          indices[${idxH}] = u32(clamp(r, 0, H - 1));
          indices[${idxW}] = u32(clamp(c, 0, W - 1));
        `;
          case "reflection":
            return `
          indices[${idxH}] = gs_reflect(r, border[1], border[3]);
          indices[${idxW}] = gs_reflect(c, border[0], border[2]);
        `;
          default:
            throw new Error(`padding mode ${attributes.paddingMode} is not supported`);
        }
      })() + `
    return ${input.getByIndices("indices")};
  }
`;
      computePixel = (output, dataType, attributes) => (() => {
        switch (attributes.mode) {
          case "nearest":
            return `
          let result = pixel_at_grid(i32(round(y)), i32(round(x)), H_in, W_in, indices[${idxN}], indices[${idxC}], border);
        `;
          case "bilinear":
            return `
          let x1 = i32(floor(x));
          let y1 = i32(floor(y));
          let x2 = x1 + 1;
          let y2 = y1 + 1;

          let p11 = pixel_at_grid(y1, x1, H_in, W_in, indices[${idxN}], indices[${idxC}], border);
          let p12 = pixel_at_grid(y1, x2, H_in, W_in, indices[${idxN}], indices[${idxC}], border);
          let p21 = pixel_at_grid(y2, x1, H_in, W_in, indices[${idxN}], indices[${idxC}], border);
          let p22 = pixel_at_grid(y2, x2, H_in, W_in, indices[${idxN}], indices[${idxC}], border);

          let dx2 = ${dataType}(f32(x2) - x);
          let dx1 = ${dataType}(x - f32(x1));
          let dy2 = ${dataType}(f32(y2) - y);
          let dy1 = ${dataType}(y - f32(y1));
          let result = dy2 * (dx2 * p11 + dx1 * p12) + dy1 * (dx2 * p21 + dx1 * p22);
        `;
          case "bicubic":
            return `
          let x0 = i32(floor(x)) - 1;
          let y0 = i32(floor(y)) - 1;
          var p: mat4x4<${dataType}>;
          for (var h = 0; h < 4; h++) {
            for (var w = 0; w < 4; w++) {
              p[h][w] = pixel_at_grid(h + y0, w + x0, H_in, W_in, indices[${idxN}], indices[${idxC}], border);
            }
          }

          let dx = x - f32(x0 + 1);
          let dy = y - f32(y0 + 1);
          let result = gs_bicubic_interpolate(p, dx, dy);
        `;
          default:
            throw new Error(`mode ${attributes.mode} is not supported`);
        }
      })() + `${output.setByOffset("global_idx", "result")}`;
      createGridSampleProgramInfo = (inputs, attributes) => {
        const x = inputVariable("x", inputs[0].dataType, inputs[0].dims.length);
        const gridShape = [inputs[1].dims[0], inputs[1].dims[1], inputs[1].dims[2]];
        const grid = inputVariable("grid", inputs[1].dataType, gridShape.length, 2);
        let outputShape = [inputs[0].dims[0], inputs[0].dims[1], inputs[1].dims[1], inputs[1].dims[2]];
        if (attributes.format === "NHWC") {
          outputShape = [inputs[0].dims[0], inputs[1].dims[1], inputs[1].dims[2], inputs[0].dims[3]];
          [idxN, idxC, idxH, idxW] = [0, 3, 1, 2];
        }
        const output = outputVariable("output", inputs[0].dataType, outputShape.length);
        const dataType = x.type.value;
        const outputSize = ShapeUtil.size(outputShape);
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          ...createTensorShapeVariables(inputs[0].dims, gridShape, outputShape)
        ];
        const getShaderSource = (shaderHelper) => `
  ${shaderHelper.registerUniform("output_size", "u32").declareVariables(x, grid, output)}
  ${gsGetCubicCoeffs}
  ${gsBicubicInterpolate(dataType)}
  ${gsDenormalize(attributes)}
  ${gsReflect(attributes)}
  ${pixelAtGrid(x, dataType, attributes)}

  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
      let H_in = i32(uniforms.x_shape[${idxH}]);
      let W_in = i32(uniforms.x_shape[${idxW}]);

      ${attributes.alignCorners === 0 ? `
      let x_min = -0.5;
      let x_max = f32(W_in) - 0.5;
      let y_min = -0.5;
      let y_max = f32(H_in) - 0.5;
      ` : `
      let x_min = 0.0;
      let x_max = f32(W_in) - 1.0;
      let y_min = 0.0;
      let y_max = f32(H_in) - 1.0;
      `};
      let border = vec4<f32>(x_min, y_min, x_max, y_max);

      let indices = ${output.offsetToIndices("global_idx")};
      var grid_indices = vec3<u32>(indices[${idxN}], indices[${idxH}], indices[${idxW}]);
      let nxy = ${grid.getByIndices("grid_indices")};
      var x = gs_denormalize(f32(nxy[0]), W_in);
      var y = gs_denormalize(f32(nxy[1]), H_in);

      ${computePixel(output, dataType, attributes)}
  }`;
        return {
          name: "GridSample",
          shaderCache: { hint: `${attributes.cacheKey}`, inputDependencies: ["type", "type"] },
          getRunData: (inputs2) => {
            const outputSize2 = ShapeUtil.size(outputShape);
            return {
              outputs: [{ dims: outputShape, dataType: inputs2[0].dataType }],
              dispatchGroup: { x: Math.ceil(
                outputSize2 / 64
                /* workgroup size */
              ) },
              programUniforms
            };
          },
          getShaderSource
        };
      };
      gridSample = (context, attributes) => {
        validateInputs16(context.inputs);
        context.compute(createGridSampleProgramInfo(context.inputs, attributes));
      };
      parseGridSampleAttributes = (attributes) => createAttributeWithCacheKey({
        alignCorners: attributes.align_corners,
        mode: attributes.mode,
        paddingMode: attributes.padding_mode,
        format: attributes.format
      });
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/multihead-attention.ts
  var getInput, validateInputs17, parseMultiHeadAttentionAttributes, weightTransposeAttribute2, addBiasTranspose, maybeTransposeToBNSHAndAddBias, multiHeadAttention;
  var init_multihead_attention = __esm({
    "web/lib/wasm/jsep/webgpu/ops/multihead-attention.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_types();
      init_attention();
      init_common();
      init_transpose();
      getInput = (inputs, i) => inputs.length > i && inputs[i].dims.length > 0 ? inputs[i] : void 0;
      validateInputs17 = (inputs, attributes) => {
        const query = inputs[0];
        const key = getInput(inputs, 1);
        const value = getInput(inputs, 2);
        const bias = getInput(inputs, 3);
        const keyPaddingMask = getInput(inputs, 4);
        const attentionBias = getInput(inputs, 5);
        const pastKey = getInput(inputs, 6);
        const pastValue = getInput(inputs, 7);
        if (query.dims.length !== 3 && query.dims.length !== 5) {
          throw new Error("Input query is expected to have 3 or 5 dimensions");
        }
        const batchSize = query.dims[0];
        const sequenceLength = query.dims[1];
        const hiddenSize = query.dims.length === 3 ? query.dims[2] : attributes.numHeads * query.dims[4];
        let kvSequenceLength = sequenceLength;
        let pastSequenceLength = 0;
        let maxSequenceLength = 0;
        const headSize = Math.floor(hiddenSize / attributes.numHeads);
        if (pastKey && pastValue && ShapeUtil.size(pastKey.dims) && ShapeUtil.size(pastValue.dims)) {
          if (pastKey.dims.length !== 4) {
            throw new Error('Input "past_key" is expected to have 4 dimensions');
          }
          if (pastKey.dims[0] !== batchSize || pastKey.dims[1] !== attributes.numHeads || pastKey.dims[3] !== headSize) {
            throw new Error('Input "past_key" shape (batch_size, num_heads, past_sequence_length, head_size)');
          }
          if (pastValue.dims[0] !== batchSize || pastValue.dims[1] !== attributes.numHeads || pastValue.dims[3] !== headSize) {
            throw new Error('Input "past_value" shape (batch_size, num_heads, past_sequence_length, head_size)');
          }
          if (pastKey.dims[2] !== pastValue.dims[2]) {
            throw new Error('Input "past_key" and "past_value" shall have same dim 2 (past_sequence_length)');
          }
          if (pastValue.dims.length !== 4) {
            throw new Error('Input "past_value" is expected to have 4 dimensions');
          }
          pastSequenceLength = pastKey.dims[2];
          maxSequenceLength = pastKey.dims[2];
        } else if (pastKey && ShapeUtil.size(pastKey.dims) || pastValue && ShapeUtil.size(pastValue.dims)) {
          throw new Error('Input "past_key" and "past_value" shall be both present or both absent');
        }
        let qkvFormat;
        if (key && ShapeUtil.size(key.dims) > 0) {
          if (query.dims.length !== 3) {
            throw new Error('Input "query" is expected to have 3 dimensions when key is given');
          }
          if (key.dims.length < 3 || key.dims.length > 5) {
            throw new Error('Input "key" is expected to have 3, 4, or 5 dimensions');
          }
          if (query.dims[0] !== key.dims[0]) {
            throw new Error('Input "query" and "key" shall have same dim 0 (batch size)');
          }
          if (key.dims.length === 3) {
            if (key.dims[2] !== query.dims[2]) {
              throw new Error('Input "query" and "key" shall have same dim 2 (hidden_size)');
            }
            qkvFormat = 2 /* qkvBSNH */;
            kvSequenceLength = key.dims[1];
          } else if (key.dims.length === 5) {
            if (key.dims[2] !== attributes.numHeads || key.dims[3] !== 2 || key.dims[4] !== headSize) {
              throw new Error('Expect "key" shape (batch_size, kv_sequence_length, num_heads, 2, head_size) for packed kv');
            }
            if (value) {
              throw new Error('Expect "value" be none when "key" has packed kv format.');
            }
            qkvFormat = 5 /* qKvBSNHxBSN2H */;
            kvSequenceLength = key.dims[1];
          } else {
            if (key.dims[1] !== attributes.numHeads || key.dims[3] !== headSize) {
              throw new Error('Expect "key" shape (batch_size, num_heads, kv_sequence_length, head_size) for past_key');
            }
            qkvFormat = 0 /* unknown */;
            kvSequenceLength = key.dims[2];
          }
        } else {
          if (query.dims.length !== 5) {
            throw new Error('Input "query" is expected to have 5 dimensions when key is empty');
          }
          if (query.dims[2] !== attributes.numHeads || query.dims[3] !== 3) {
            throw new Error('Expect "query" shape (batch_size, kv_sequence_length, num_heads, 3, head_size) for packed kv');
          }
          qkvFormat = 3 /* qkvBSN3H */;
        }
        if (bias && ShapeUtil.size(bias.dims) > 0) {
          if (bias.dims.length !== 1) {
            throw new Error('Input "bias" is expected to have 1 dimension');
          }
          if (key) {
            if (key.dims.length === 5 && key.dims[3] === 2) {
              throw new Error("bias is not allowed for packed kv.");
            }
          }
        }
        const totalSequenceLength = pastSequenceLength + kvSequenceLength;
        let maskType = 0 /* none */;
        if (keyPaddingMask && ShapeUtil.size(keyPaddingMask.dims) > 0) {
          maskType = 8 /* maskUnknown */;
          const maskDims = keyPaddingMask.dims;
          if (maskDims.length === 1) {
            if (maskDims[0] === batchSize) {
              maskType = 1 /* mask1dKeySeqLen */;
            } else if (maskDims[0] === 3 * batchSize + 2) {
              maskType = 3 /* mask1DKeySeqLenStart */;
            }
          } else if (maskDims.length === 2 && maskDims[0] === batchSize && maskDims[1] === totalSequenceLength) {
            maskType = 5 /* mask2dKeyPadding */;
          }
          if (maskType === 8 /* maskUnknown */) {
            throw new Error('Input "key_padding_mask" shape shall be (batch_size) or (batch_size, total_sequence_length)');
          }
          throw new Error("Mask not supported");
        }
        let passPastInKv = false;
        let vHiddenSize = hiddenSize;
        if (value && ShapeUtil.size(value.dims) > 0) {
          if (value.dims.length !== 3 && value.dims.length !== 4) {
            throw new Error('Input "value" is expected to have 3 or 4 dimensions');
          }
          if (query.dims[0] !== value.dims[0]) {
            throw new Error('Input "query" and "value" shall have same dim 0 (batch_size)');
          }
          if (value.dims.length === 3) {
            if (kvSequenceLength !== value.dims[1]) {
              throw new Error('Input "key" and "value" shall have the same dim 1 (kv_sequence_length)');
            }
            vHiddenSize = value.dims[2];
          } else {
            if (kvSequenceLength !== value.dims[2]) {
              throw new Error('Input "key" and "value" shall have the same dim 2 (kv_sequence_length)');
            }
            vHiddenSize = value.dims[1] * value.dims[3];
            passPastInKv = true;
          }
        }
        const broadcastResPosBias = false;
        if (keyPaddingMask && ShapeUtil.size(keyPaddingMask.dims) > 0) {
          throw new Error("Key padding mask is not supported");
        }
        if (attentionBias && ShapeUtil.size(attentionBias.dims) > 0) {
          if (attentionBias.dims.length !== 4) {
            throw new Error('Input "attention_bias" is expected to have 4 dimensions');
          }
          if (attentionBias.dims[0] !== batchSize || attentionBias.dims[1] !== attributes.numHeads || attentionBias.dims[2] !== sequenceLength || attentionBias.dims[3] !== totalSequenceLength) {
            throw new Error('Expect "attention_bias" shape (batch_size, num_heads, sequence_length, total_sequence_length)');
          }
        }
        return {
          batchSize,
          sequenceLength,
          pastSequenceLength,
          kvSequenceLength,
          totalSequenceLength,
          maxSequenceLength,
          inputHiddenSize: 0,
          hiddenSize,
          vHiddenSize,
          headSize,
          vHeadSize: Math.floor(vHiddenSize / attributes.numHeads),
          numHeads: attributes.numHeads,
          isUnidirectional: false,
          pastPresentShareBuffer: false,
          maskFilterValue: attributes.maskFilterValue,
          maskType,
          scale: attributes.scale,
          broadcastResPosBias,
          passPastInKv,
          qkvFormat
        };
      };
      parseMultiHeadAttentionAttributes = (attributes) => createAttributeWithCacheKey({ ...attributes });
      weightTransposeAttribute2 = createAttributeWithCacheKey({ perm: [0, 2, 1, 3] });
      addBiasTranspose = (context, qkv, bias, batchSize, sequenceLength, hiddenSize, biasOffset) => {
        const outputShape = [batchSize, sequenceLength, hiddenSize];
        const outputSize = ShapeUtil.size(outputShape);
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 12 /* uint32 */, data: biasOffset },
          { type: 12 /* uint32 */, data: hiddenSize }
        ];
        const getShaderSource = (shaderHelper) => {
          const output = outputVariable("qkv_with_bias", qkv.dataType, outputShape);
          const qkvInput = inputVariable("qkv", qkv.dataType, outputShape);
          const biasInput = inputVariable("bias", bias.dataType, outputShape);
          const uniforms = [
            { name: "output_size", type: "u32" },
            { name: "bias_offset", type: "u32" },
            { name: "hidden_size", type: "u32" }
          ];
          return `
  ${shaderHelper.registerUniforms(uniforms).declareVariables(qkvInput, biasInput, output)}
  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
    let bias_offset_idx = (global_idx % uniforms.hidden_size) + uniforms.bias_offset;

    qkv_with_bias[global_idx] = qkv[global_idx] + bias[bias_offset_idx];
  }`;
        };
        return context.compute(
          {
            name: "MultiHeadAttentionAddBias",
            shaderCache: { inputDependencies: ["type", "type"] },
            getRunData: () => ({
              outputs: [{ dims: outputShape, dataType: qkv.dataType, gpuDataType: 0 /* default */ }],
              dispatchGroup: { x: Math.ceil(
                outputSize / 64
                /* workgroup size */
              ) },
              programUniforms
            }),
            getShaderSource
          },
          { inputs: [qkv, bias], outputs: [-1] }
        )[0];
      };
      maybeTransposeToBNSHAndAddBias = (context, batchSize, numHeads, sequenceLength, headSize, input, bias, biasOffset) => {
        let reshapedInput = input;
        if (!(bias && ShapeUtil.size(bias.dims) > 0)) {
          if (input.dims.length === 3) {
            reshapedInput = input.reshape([batchSize, sequenceLength, numHeads, headSize]);
          }
          if (numHeads === 1 || sequenceLength === 1) {
            return reshapedInput;
          }
          return context.compute(createTransposeProgramInfo(reshapedInput, weightTransposeAttribute2.perm), {
            inputs: [reshapedInput],
            outputs: [-1]
          })[0];
        } else {
          if (sequenceLength === 1) {
            throw new Error("AddBiasReshape is not implemented. Please export your model with packed QKV or KV");
          } else {
            reshapedInput = addBiasTranspose(
              context,
              input,
              bias,
              batchSize,
              sequenceLength,
              numHeads * headSize,
              biasOffset
            );
            reshapedInput = reshapedInput.reshape([batchSize, sequenceLength, numHeads, headSize]);
            if (numHeads === 1 || sequenceLength === 1) {
              return reshapedInput;
            }
            return context.compute(createTransposeProgramInfo(reshapedInput, weightTransposeAttribute2.perm), {
              inputs: [reshapedInput],
              outputs: [-1]
            })[0];
          }
        }
      };
      multiHeadAttention = (context, attributes) => {
        const params = validateInputs17(context.inputs, attributes);
        const query = context.inputs[0];
        const key = getInput(context.inputs, 1);
        const value = getInput(context.inputs, 2);
        const bias = getInput(context.inputs, 3);
        const keyPaddingMask = getInput(context.inputs, 4);
        const attentionBias = getInput(context.inputs, 5);
        const pastKey = getInput(context.inputs, 6);
        const pastValue = getInput(context.inputs, 7);
        if (query.dims.length === 5) {
          throw new Error("Packed QKV is not implemented");
        }
        if (key?.dims.length === 5) {
          throw new Error("Packed KV is not implemented");
        }
        const kvBNSH = key && value && key.dims.length === 4 && value.dims.length === 4;
        const Q = maybeTransposeToBNSHAndAddBias(
          context,
          params.batchSize,
          params.numHeads,
          params.sequenceLength,
          params.headSize,
          query,
          bias,
          0
        );
        if (kvBNSH) {
          return applyAttention(context, Q, key, value, keyPaddingMask, void 0, pastKey, pastValue, attentionBias, params);
        }
        if (!key || !value) {
          throw new Error("key and value must be provided");
        }
        const K = maybeTransposeToBNSHAndAddBias(
          context,
          params.batchSize,
          params.numHeads,
          params.kvSequenceLength,
          params.headSize,
          key,
          bias,
          params.hiddenSize
        );
        const V = maybeTransposeToBNSHAndAddBias(
          context,
          params.batchSize,
          params.numHeads,
          params.kvSequenceLength,
          params.vHeadSize,
          value,
          bias,
          2 * params.hiddenSize
        );
        applyAttention(context, Q, K, V, keyPaddingMask, void 0, pastKey, pastValue, attentionBias, params);
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/split.ts
  var validateInputs18, createSplitAttributesFromInputs, calculateOutputIndexImpl, writeBufferDataImpl, createSplitProgramInfo, split, parseSplitAttributes;
  var init_split = __esm({
    "web/lib/wasm/jsep/webgpu/ops/split.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      validateInputs18 = (inputs) => {
        if (!inputs || inputs.length < 1) {
          throw new Error("too few inputs");
        }
      };
      createSplitAttributesFromInputs = (inputs, attributes) => {
        const splitSizes = [];
        let numOutputs = attributes.numOutputs;
        if (inputs[1].dims[0] > 0) {
          inputs[1].getBigInt64Array().forEach((v) => splitSizes.push(Number(v)));
          numOutputs = splitSizes.length;
        }
        return createAttributeWithCacheKey({ numOutputs, axis: attributes.axis, splitSizes });
      };
      calculateOutputIndexImpl = (numberOfTensors) => `
fn calculateOutputIndex(index: u32) -> u32 {
    for (var i: u32 = 0u; i < ${numberOfTensors}u; i += 1u ) {
    if (index < ${getElementAt("uniforms.size_in_split_axis", "i", numberOfTensors)}) {
        return i;
    }
    }
    return ${numberOfTensors}u;
}`;
      writeBufferDataImpl = (outputs) => {
        const numberOfTensors = outputs.length;
        const codeLines = [];
        for (let i = 0; i < numberOfTensors; ++i) {
          const returnSnippet = outputs[i].setByIndices("indices", "input[global_idx]");
          if (numberOfTensors === 1) {
            codeLines.push(returnSnippet);
          } else if (i === 0) {
            codeLines.push(`if (output_number == ${i}u) { ${returnSnippet} }`);
          } else if (i === numberOfTensors - 1) {
            codeLines.push(`else { ${returnSnippet} }`);
          } else {
            codeLines.push(`else if (output_number == ${i}) { ${returnSnippet} }`);
          }
        }
        return `
      fn writeBufferData(output_number: u32, indices: ${outputs[0].type.indices}, global_idx: u32) {
        ${codeLines.join("\n")}
      }`;
      };
      createSplitProgramInfo = (inputs, attributes) => {
        const inputShape = inputs[0].dims;
        const inputSize = ShapeUtil.size(inputShape);
        const dataType = inputs[0].dataType;
        const axis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);
        const outputs = new Array(attributes.numOutputs);
        const input = inputVariable("input", dataType, inputShape.length);
        const sizeInSplitAxis = new Array(attributes.numOutputs);
        const outputsTensorInfo = [];
        const outputShapes = [];
        let previousSum = 0;
        const programUniforms = [{ type: 12 /* uint32 */, data: inputSize }];
        for (let i = 0; i < attributes.numOutputs; i++) {
          previousSum += attributes.splitSizes[i];
          sizeInSplitAxis[i] = previousSum;
          const outputShape = inputShape.slice();
          outputShape[axis] = attributes.splitSizes[i];
          outputShapes.push(outputShape);
          outputs[i] = outputVariable(`output${i}`, dataType, outputShape.length);
          outputsTensorInfo.push({ dims: outputShapes[i], dataType: inputs[0].dataType });
        }
        programUniforms.push(
          { type: 12 /* uint32 */, data: sizeInSplitAxis },
          ...createTensorShapeVariables(inputShape, ...outputShapes)
        );
        const getShaderSource = (shaderHelper) => `
  ${shaderHelper.registerUniform("input_size", "u32").registerUniform("size_in_split_axis", "u32", sizeInSplitAxis.length).declareVariables(input, ...outputs)}
  ${calculateOutputIndexImpl(sizeInSplitAxis.length)}
  ${writeBufferDataImpl(outputs)}

  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.input_size")}

    var indices = ${input.offsetToIndices("global_idx")};
    var index = ${input.indicesGet("indices", axis)};
    let output_number = calculateOutputIndex(index);
    if (output_number != 0) {
      index -= ${getElementAt("uniforms.size_in_split_axis", "output_number - 1u", sizeInSplitAxis.length)};
      ${input.indicesSet("indices", axis, "index")};
    }
    writeBufferData(output_number, indices, global_idx);
  }`;
        return {
          name: "Split",
          shaderCache: { hint: attributes.cacheKey, inputDependencies: ["rank"] },
          getShaderSource,
          getRunData: () => ({
            outputs: outputsTensorInfo,
            dispatchGroup: { x: Math.ceil(
              inputSize / 64
              /* workgroup size */
            ) },
            programUniforms
          })
        };
      };
      split = (context, attributes) => {
        validateInputs18(context.inputs);
        const updatedAttributes = context.inputs.length === 1 ? attributes : createSplitAttributesFromInputs(context.inputs, attributes);
        context.compute(createSplitProgramInfo(context.inputs, updatedAttributes), { inputs: [0] });
      };
      parseSplitAttributes = (attributes) => {
        const axis = attributes.axis;
        const splitSizes = attributes.splitSizes;
        const numOutputs = attributes.numOutputs < 0 ? splitSizes.length : attributes.numOutputs;
        if (numOutputs !== splitSizes.length) {
          throw new Error("numOutputs and splitSizes length must be equal");
        }
        return createAttributeWithCacheKey({ axis, numOutputs, splitSizes });
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/rotary-embedding.ts
  var validateInputs19, createRotaryEmbeddingProgramInfo, rotaryEmbedding;
  var init_rotary_embedding = __esm({
    "web/lib/wasm/jsep/webgpu/ops/rotary-embedding.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      validateInputs19 = (inputs, attributes) => {
        const [input, positionIds, cosCache, sinCache] = inputs;
        const { numHeads, rotaryEmbeddingDim } = attributes;
        if (input.dims.length !== 3 && input.dims.length !== 4) {
          throw new Error(`Input 'x' is expected to have 3 or 4 dimensions, got ${input.dims.length}`);
        }
        if (!ShapeUtil.areEqual(positionIds.dims, []) && !ShapeUtil.areEqual(positionIds.dims, [1]) && positionIds.dims.length !== 2) {
          throw new Error(`Input 'position_ids' is expected to have 0, 1, or 2 dimensions, got ${positionIds.dims.length}`);
        }
        if (cosCache.dims.length !== 2) {
          throw new Error(`Input 'cos_cache' is expected to have 2 dimensions, got ${cosCache.dims.length}`);
        }
        if (sinCache.dims.length !== 2) {
          throw new Error(`Input 'sin_cache' is expected to have 2 dimensions, got ${sinCache.dims.length}`);
        }
        if (!ShapeUtil.areEqual(cosCache.dims, sinCache.dims)) {
          throw new Error("Inputs 'cos_cache' and 'sin_cache' are expected to have the same shape");
        }
        if (rotaryEmbeddingDim > 0 && numHeads === 0) {
          throw new Error("num_heads must be provided if rotary_embedding_dim is specified");
        }
        const batchSize = input.dims[0];
        const sequenceLength = input.dims[input.dims.length - 2];
        const maxSequenceLength = cosCache.dims[0];
        const hiddenSize = ShapeUtil.sizeFromDimension(input.dims, 1) / sequenceLength;
        const headSize = rotaryEmbeddingDim === 0 ? cosCache.dims[1] * 2 : hiddenSize / numHeads;
        if (rotaryEmbeddingDim > headSize) {
          throw new Error("rotary_embedding_dim must be less than or equal to head_size");
        }
        if (positionIds.dims.length === 2) {
          if (batchSize !== positionIds.dims[0]) {
            throw new Error(`Input 'position_ids' dimension 0 should be of size batch_size, got ${positionIds.dims[0]}`);
          }
          if (sequenceLength !== positionIds.dims[1]) {
            throw new Error(`Input 'position_ids' dimension 1 should be of size sequence_length, got ${positionIds.dims[1]}`);
          }
        }
        if (sequenceLength > maxSequenceLength) {
          throw new Error("Updating cos_cache and sin_cache in RotaryEmbedding is not currently supported");
        }
        if (headSize / 2 !== cosCache.dims[1] && rotaryEmbeddingDim / 2 !== cosCache.dims[1]) {
          throw new Error(
            `Input 'cos_cache' dimension 1 should be same as head_size / 2 or rotary_embedding_dim / 2, got ${cosCache.dims[1]}`
          );
        }
      };
      createRotaryEmbeddingProgramInfo = (inputs, attributes) => {
        const { interleaved, numHeads, rotaryEmbeddingDim, scale } = attributes;
        const batchSize = inputs[0].dims[0];
        const batchStride = ShapeUtil.sizeFromDimension(inputs[0].dims, 1);
        const sequenceLength = inputs[0].dims[inputs[0].dims.length - 2];
        const hiddenSize = batchStride / sequenceLength;
        const halfRotaryEmbeddingDim = inputs[2].dims[1];
        const headSize = rotaryEmbeddingDim === 0 ? halfRotaryEmbeddingDim * 2 : hiddenSize / numHeads;
        const globalShape = new Array(
          batchSize,
          sequenceLength,
          hiddenSize / headSize,
          headSize - halfRotaryEmbeddingDim
        );
        const globalStrides = ShapeUtil.computeStrides(globalShape);
        const programUniforms = [
          { type: 1 /* float */, data: scale },
          { type: 12 /* uint32 */, data: globalShape },
          { type: 12 /* uint32 */, data: globalStrides },
          // strides for addressing the input/output tensor, in permutated order to align with the unfolded global index,
          // i.e. BSNH
          ...inputs[0].dims.length === 3 ? new Array({ type: 12 /* uint32 */, data: [batchStride, hiddenSize, headSize, 1] }) : [],
          ...inputs[0].dims.length === 4 ? new Array({
            type: 12 /* uint32 */,
            data: [batchStride, headSize, sequenceLength * headSize, 1]
          }) : [],
          ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, inputs[2].dims, inputs[3].dims, inputs[0].dims)
        ];
        const getShaderSource = (shaderHelper) => {
          const input = inputVariable("input", inputs[0].dataType, inputs[0].dims.length);
          const positionIds = inputVariable("position_ids", inputs[1].dataType, inputs[1].dims.length);
          const cosCache = inputVariable("cos_cache", inputs[2].dataType, inputs[2].dims.length);
          const sinCache = inputVariable("sin_cache", inputs[3].dataType, inputs[3].dims.length);
          const output = outputVariable("output", inputs[0].dataType, inputs[0].dims.length);
          shaderHelper.registerUniforms([
            { name: "scale", type: "f32" },
            { name: "global_shape", type: "u32", length: globalShape.length },
            { name: "global_strides", type: "u32", length: globalStrides.length },
            { name: "input_output_strides", type: "u32", length: globalStrides.length }
          ]);
          return `
        ${shaderHelper.declareVariables(input, positionIds, cosCache, sinCache, output)}

        ${shaderHelper.mainStart(WORKGROUP_SIZE)}
          let half_rotary_emb_dim = uniforms.${cosCache.name}_shape[1];
          let bsnh = global_idx / uniforms.global_strides % uniforms.global_shape;
          let size = uniforms.global_shape[0] * uniforms.global_strides[0];
          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("size")}

          if (bsnh[3] < half_rotary_emb_dim) {
            let position_ids_idx =
                ${positionIds.broadcastedIndicesToOffset("bsnh.xy", outputVariable("", positionIds.type.tensor, 2))};
            let position_id =
                u32(${positionIds.getByOffset("position_ids_idx")}) + select(0, bsnh[1], position_ids_idx == 0);
            let i = dot(bsnh, uniforms.input_output_strides) + select(0, bsnh[3], ${interleaved});
            let j = i + select(half_rotary_emb_dim, 1, ${interleaved});
            let re = ${input.getByOffset("i")} * ${cosCache.get("position_id", "bsnh[3]")} -
                ${input.getByOffset("j")} * ${sinCache.get("position_id", "bsnh[3]")};
            ${output.setByOffset("i", "re")}
            let im = ${input.getByOffset("i")} * ${sinCache.get("position_id", "bsnh[3]")} +
                ${input.getByOffset("j")} * ${cosCache.get("position_id", "bsnh[3]")};
            ${output.setByOffset("j", "im")}
          } else {
            let k = dot(bsnh, uniforms.input_output_strides) + half_rotary_emb_dim;
            ${output.setByOffset("k", input.getByOffset("k"))}
          }
        }`;
        };
        return {
          name: "RotaryEmbedding",
          shaderCache: {
            hint: createAttributeWithCacheKey({
              interleaved
            }).cacheKey,
            inputDependencies: ["rank", "rank", "rank", "rank"]
          },
          getShaderSource,
          getRunData: () => ({
            outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }],
            dispatchGroup: { x: Math.ceil(ShapeUtil.size(globalShape) / WORKGROUP_SIZE) },
            programUniforms
          })
        };
      };
      rotaryEmbedding = (context, attributes) => {
        validateInputs19(context.inputs, attributes);
        context.compute(createRotaryEmbeddingProgramInfo(context.inputs, attributes));
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/group-query-attention.ts
  var validateInputs20, weightTransposeAttribute3, maybeTransposeToBNSH, generatePositionIdsProgramInfo, groupQueryAttention;
  var init_group_query_attention = __esm({
    "web/lib/wasm/jsep/webgpu/ops/group-query-attention.ts"() {
      "use strict";
      init_attribute_with_cache_key();
      init_wasm_common();
      init_attention();
      init_multihead_attention();
      init_split();
      init_transpose();
      init_rotary_embedding();
      init_common();
      validateInputs20 = (inputs, attributes) => {
        if (attributes.doRotary && inputs.length <= 7) {
          throw new Error("cos_cache and sin_cache inputs are required if do_rotary is specified");
        }
        const query = inputs[0];
        const key = inputs[1];
        const value = inputs[2];
        const pastKey = inputs[3];
        const pastValue = inputs[4];
        if (attributes.doRotary !== 0 && inputs.length <= 7) {
          throw new Error("cos_cast and sin_cache are expected if do_rotary attribute is non-zero");
        }
        if (attributes.localWindowSize !== -1) {
          throw new Error("Local attention is not supported");
        }
        if (attributes.softcap !== 0) {
          throw new Error("Softcap is not supported");
        }
        if (attributes.rotaryInterleaved !== 0) {
          throw new Error("Rotary interleaved is not supported");
        }
        if (attributes.smoothSoftmax) {
          throw new Error("Smooth softmax is not supported");
        }
        if (query.dims.length !== 3 && query.dims.length !== 5) {
          throw new Error("Input query is expected to have 3 or 5 dimensions");
        }
        const dmmhaPacking = false;
        const batchSize = query.dims[0];
        const sequenceLength = query.dims[1];
        let hiddenSize = query.dims.length === 3 ? dmmhaPacking ? query.dims[2] / 3 : query.dims[2] : attributes.numHeads * query.dims[4];
        let kvSequenceLength = sequenceLength;
        let pastSequenceLength = 0;
        const packedQKV = !key || key.dims.length === 0;
        const headSize = !packedQKV ? Math.floor(hiddenSize / attributes.numHeads) : Math.floor(hiddenSize / (attributes.numHeads + 2 * attributes.kvNumHeads));
        if (packedQKV) {
          hiddenSize = headSize * attributes.numHeads;
        }
        const hasPastKey = pastKey && pastKey.dims.length !== 0;
        const hasPastValue = pastValue && pastValue.dims.length !== 0;
        const isPastkvBSNH = hasPastKey && pastKey.dims.length === 4 && pastKey.dims[0] === batchSize && pastKey.dims[1] !== attributes.kvNumHeads && pastKey.dims[2] === attributes.kvNumHeads && pastKey.dims[3] === headSize;
        if (isPastkvBSNH) {
          throw new Error("BSNH pastKey/pastValue is not supported");
        }
        if (hasPastKey && hasPastValue) {
          if (pastKey.dims.length !== 4) {
            throw new Error('Input "past_key" is expected to have 4 dimensions');
          }
          if (pastValue.dims.length !== 4) {
            throw new Error('Input "past_value" is expected to have 4 dimensions');
          }
          pastSequenceLength = pastKey.dims[2];
        } else if (hasPastKey || hasPastValue) {
          throw new Error('Input "past_key" and "past_value" shall be both present or both absent');
        }
        let qkvFormat = 1 /* qkvBNSH */;
        if (key && key.dims.length > 0) {
          if (query.dims.length !== 3) {
            throw new Error('Input "query" is expected to have 3 dimensions when key is given');
          }
          if (key.dims.length < 3 || key.dims.length > 5) {
            throw new Error('Input "key" is expected to have 3, 4, or 5 dimensions');
          }
          if (query.dims[0] !== key.dims[0]) {
            throw new Error('Input "query" and "key" shall have same dim 0 (batch size)');
          }
          if (key.dims.length === 3) {
            if (query.dims[2] % key.dims[2] !== 0) {
              throw new Error('Dimension 2 of "query" should be a multiple of "key"');
            }
            kvSequenceLength = key.dims[1];
          } else if (key.dims.length === 5) {
            if (key.dims[2] !== attributes.numHeads || key.dims[3] !== 2 || key.dims[4] !== headSize) {
              throw new Error('Expect "key" shape (batch_size, kv_sequence_length, num_heads, 2, head_size) for packed kv');
            }
            if (value) {
              throw new Error('Expect "value" be none when "key" has packed kv format.');
            }
            kvSequenceLength = key.dims[1];
          } else {
            if (key.dims[1] !== attributes.numHeads || key.dims[3] !== headSize) {
              throw new Error('Expect "key" shape (batch_size, num_heads, kv_sequence_length, head_size) for past_key');
            }
            kvSequenceLength = key.dims[2];
          }
        } else {
          if (query.dims.length !== 3 && query.dims.length !== 5) {
            throw new Error('Input "query" is expected to have 3 or 5 dimensions when key is empty');
          }
          if (query.dims.length === 5 && (query.dims[2] !== attributes.numHeads || query.dims[3] !== 3)) {
            throw new Error('Expect "query" shape (batch_size, kv_sequence_length, num_heads, 3, head_size) for packed kv');
          }
          qkvFormat = 3 /* qkvBSN3H */;
        }
        const maskType = 0 /* none */;
        let passPastInKv = false;
        let vHiddenSize = attributes.kvNumHeads ? headSize * attributes.kvNumHeads : hiddenSize;
        if (value && value.dims.length > 0) {
          if (value.dims.length !== 3 && value.dims.length !== 4) {
            throw new Error('Input "value" is expected to have 3 or 4 dimensions');
          }
          if (query.dims[0] !== value.dims[0]) {
            throw new Error('Input "query" and "value" shall have same dim 0 (batch_size)');
          }
          if (value.dims.length === 3) {
            if (kvSequenceLength !== value.dims[1]) {
              throw new Error('Input "key" and "value" shall have the same dim 1 (kv_sequence_length)');
            }
            vHiddenSize = value.dims[2];
          } else {
            if (kvSequenceLength !== value.dims[2]) {
              throw new Error('Input "past_key" and "past_value" shall have the same dim 2 (kv_sequence_length)');
            }
            vHiddenSize = value.dims[1] * value.dims[3];
            passPastInKv = true;
          }
        }
        const seqlLens = inputs.length > 4 ? inputs[5] : void 0;
        if (seqlLens) {
          if (seqlLens.dims.length === 0) {
            throw new Error("seqlens_k must be at least 1D, got scalar.");
          }
          const seqlLenSize = seqlLens.dims.reduce((a, b) => a * b, 1);
          if (seqlLenSize !== batchSize) {
            throw new Error(`seqlens_k must have batch_size (${batchSize}) elements, got ${seqlLenSize}.`);
          }
          for (let i = 0; i < seqlLens.dims.length; i++) {
            if (seqlLens.dims[i] !== 1 && seqlLens.dims[i] !== batchSize) {
              throw new Error(
                `seqlens_k has unexpected shape. Each dimension must be 1 or batch_size (${batchSize}), got dims[${i}] = ${seqlLens.dims[i]}.`
              );
            }
          }
        }
        const totalSequenceLength = -1;
        const maxSequenceLength = -1;
        const broadcastResPosBias = false;
        return {
          batchSize,
          sequenceLength,
          pastSequenceLength,
          kvSequenceLength,
          totalSequenceLength,
          maxSequenceLength,
          inputHiddenSize: 0,
          hiddenSize,
          vHiddenSize,
          headSize,
          vHeadSize: Math.floor(vHiddenSize / attributes.kvNumHeads),
          numHeads: attributes.numHeads,
          kvNumHeads: attributes.kvNumHeads,
          nReps: attributes.numHeads / attributes.kvNumHeads,
          pastPresentShareBuffer: false,
          maskType,
          scale: attributes.scale,
          broadcastResPosBias,
          passPastInKv,
          qkvFormat
        };
      };
      weightTransposeAttribute3 = createAttributeWithCacheKey({ perm: [0, 2, 1, 3] });
      maybeTransposeToBNSH = (context, input, params) => {
        let reshapedInput = input;
        const numHeads = params.kvNumHeads;
        if (input.dims.length === 3 && params.kvSequenceLength !== 0) {
          reshapedInput = input.reshape([params.batchSize, params.kvSequenceLength, numHeads, params.headSize]);
          reshapedInput = context.compute(createTransposeProgramInfo(reshapedInput, weightTransposeAttribute3.perm), {
            inputs: [reshapedInput],
            outputs: [-1]
          })[0];
        }
        return reshapedInput;
      };
      generatePositionIdsProgramInfo = (batchSize, sequenceLength, seqLens, totalSeqLen) => {
        const outputDataType = 7 /* int64 */;
        const inputDependencies = ["type", "type"];
        const outputShape = [batchSize * sequenceLength];
        const outputSize = batchSize * sequenceLength;
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 12 /* uint32 */, data: sequenceLength },
          { type: 12 /* uint32 */, data: batchSize }
        ];
        const getShaderSource = (shaderHelper) => {
          const seqLensInputHelper = inputVariable("seq_lens", seqLens.dataType, seqLens.dims);
          const totalSeqLenInputHelper = inputVariable("total_seq_lens", totalSeqLen.dataType, totalSeqLen.dims);
          const positionIdsHelper = outputVariable("pos_ids", outputDataType, outputShape);
          const uniforms = [
            { name: "output_size", type: "u32" },
            { name: "sequence_length", type: "u32" },
            { name: "batch_size", type: "u32" }
          ];
          return `
  ${shaderHelper.registerUniforms(uniforms).declareVariables(seqLensInputHelper, totalSeqLenInputHelper, positionIdsHelper)}
  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
    let total_sequence_length = u32(${totalSeqLenInputHelper.getByOffset("0")});
    let is_subsequent_prompt = uniforms.sequence_length > 1 && uniforms.sequence_length != total_sequence_length;
    let is_first_prompt = !is_subsequent_prompt && uniforms.sequence_length == total_sequence_length;
    let batch_idx = global_idx / uniforms.sequence_length;
    let sequence_idx = i32(global_idx % uniforms.sequence_length);
    var pos_id: i32 = 0;
    let seqlen = ${seqLensInputHelper.getByOffset("batch_idx")};
    let total_seqlen = seqlen + 1;
    if (is_first_prompt) {
      if (sequence_idx < total_seqlen) {
        pos_id = sequence_idx;
      } else {
        pos_id = 1;
      }
      ${positionIdsHelper.setByOffset("global_idx", "pos_id")}
    } else if (is_subsequent_prompt) {
      let past_seqlen = total_seqlen - i32(uniforms.sequence_length);
      if (past_seqlen + sequence_idx < total_seqlen) {
        pos_id = past_seqlen + sequence_idx;
      } else {
        pos_id = 1;
      }
      ${positionIdsHelper.setByOffset("global_idx", "pos_id")}
    } else if (global_idx < uniforms.batch_size) {
      ${positionIdsHelper.setByOffset("global_idx", "seqlen")}
    };
  }
  `;
        };
        return {
          name: "GeneratePositionIds",
          shaderCache: { hint: `${batchSize};${sequenceLength}`, inputDependencies },
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: outputDataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms
          }),
          getShaderSource
        };
      };
      groupQueryAttention = (context, attributes) => {
        const params = validateInputs20(context.inputs, attributes);
        if (context.inputs[0].dims.length === 5) {
          throw new Error("Packed QKV is not implemented");
        }
        if (context.inputs[1]?.dims.length === 5) {
          throw new Error("Packed KV is not implemented");
        }
        const q = context.inputs[0];
        const k = context.inputs[1] && context.inputs[1].dims.length > 0 ? context.inputs[1] : void 0;
        const v = context.inputs[2] && context.inputs[2].dims.length > 0 ? context.inputs[2] : void 0;
        const pastKey = context.inputs[3] && context.inputs[3].dims.length !== 0 ? context.inputs[3] : void 0;
        const pastValue = context.inputs[4] && context.inputs[4].dims.length !== 0 ? context.inputs[4] : void 0;
        const seqLens = context.inputs.length > 4 ? context.inputs[5] : void 0;
        const totalSequenceLengthInput = context.inputs.length > 5 ? context.inputs[6] : void 0;
        const kvNumHeads = params.kvNumHeads ? params.kvNumHeads : params.numHeads;
        const splitAttributes = createAttributeWithCacheKey({
          axis: 2,
          numOutputs: 3,
          splitSizes: [params.numHeads * params.headSize, kvNumHeads * params.headSize, kvNumHeads * params.headSize]
        });
        const [query, key, value] = !k && !v ? context.compute(createSplitProgramInfo([q], splitAttributes), { inputs: [q], outputs: [-1, -1, -1] }) : [q, k, v];
        let qRotary;
        let kRotary;
        if (attributes.doRotary) {
          const posIds = context.compute(
            generatePositionIdsProgramInfo(params.batchSize, params.sequenceLength, seqLens, totalSequenceLengthInput),
            { inputs: [seqLens, totalSequenceLengthInput], outputs: [-1] }
          )[0];
          const cosCache = context.inputs[7];
          const sinCache = context.inputs[8];
          const qRotaryEmbeddingAttributes = createAttributeWithCacheKey({
            interleaved: attributes.rotaryInterleaved !== 0,
            numHeads: params.numHeads,
            rotaryEmbeddingDim: 0,
            scale: attributes.scale
          });
          const inputs = [query, posIds, cosCache, sinCache];
          const outputs = [-1];
          qRotary = context.compute(createRotaryEmbeddingProgramInfo(inputs, qRotaryEmbeddingAttributes), {
            inputs,
            outputs
          })[0];
          inputs.splice(0, 1, key);
          const kRotaryEmbeddingAttributes = createAttributeWithCacheKey({
            interleaved: attributes.rotaryInterleaved !== 0,
            numHeads: params.kvNumHeads,
            rotaryEmbeddingDim: 0,
            scale: attributes.scale
          });
          kRotary = context.compute(createRotaryEmbeddingProgramInfo(inputs, kRotaryEmbeddingAttributes), {
            inputs,
            outputs
          })[0];
        }
        const Q = maybeTransposeToBNSHAndAddBias(
          context,
          params.batchSize,
          params.numHeads,
          params.sequenceLength,
          params.headSize,
          attributes.doRotary ? qRotary : query,
          void 0,
          0
        );
        const K = maybeTransposeToBNSH(context, attributes.doRotary ? kRotary : key, params);
        const V = maybeTransposeToBNSH(context, value, params);
        applyAttention(
          context,
          Q,
          K,
          V,
          void 0,
          void 0,
          pastKey,
          pastValue,
          void 0,
          params,
          seqLens,
          totalSequenceLengthInput
        );
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/instance-norm.ts
  var computeChannelScaleShift, createInstanceNormProgramInfo, createInstanceNormNHWCProgramInfo, instanceNorm;
  var init_instance_norm = __esm({
    "web/lib/wasm/jsep/webgpu/ops/instance-norm.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_transpose();
      init_common();
      computeChannelScaleShift = (context, input, scale, bias, n, h, c, epsilon) => {
        const components = getMaxComponents(h);
        const f32Type = components === 1 ? "f32" : `vec${components}f`;
        const wgType = components === 1 ? "vec2f" : `mat2x${components}f`;
        const unitsOfWork = n * c;
        let workgroupSize = 64;
        if (unitsOfWork === 1) {
          workgroupSize = 256;
        }
        const inputShape = [n, c, h / components];
        const outputShape = [n, c, 2];
        const inputDependencies = ["rank", "type", "type"];
        const programUniforms = [];
        programUniforms.push(...createTensorShapeVariables(inputShape, outputShape));
        const getShaderSource = (shaderHelper) => {
          const x = inputVariable("x", input.dataType, 3, components);
          const s = inputVariable("scale", scale.dataType, scale.dims);
          const b = inputVariable("bias", bias.dataType, bias.dims);
          const output = outputVariable("output", 1 /* float */, 3, 2);
          const variables = [x, s, b, output];
          return `
  var<workgroup> workgroup_shared : array<${wgType}, ${workgroupSize}>;
  const workgroup_size = ${workgroupSize}u;
  ${shaderHelper.declareVariables(...variables)}
  ${shaderHelper.mainStart(workgroupSize)}
    let batch = workgroup_index / uniforms.x_shape[1];
    let channel = workgroup_index % uniforms.x_shape[1];
    let hight = uniforms.x_shape[2];
    // initialize workgroup memory
    var sum = ${f32Type}(0);
    var squared_sum = ${f32Type}(0);
    for (var h = local_idx; h < hight; h += workgroup_size) {
      let value = ${f32Type}(${x.get("batch", "channel", "h")});
      sum += value;
      squared_sum += value * value;
    }
    workgroup_shared[local_idx] = ${wgType}(sum, squared_sum);
    workgroupBarrier();

    for (var currSize = workgroup_size >> 1;  currSize > 0; currSize = currSize >> 1) {
      if (local_idx < currSize) {
        workgroup_shared[local_idx] = workgroup_shared[local_idx] + workgroup_shared[local_idx + currSize];
      }
      workgroupBarrier();
    }
    if (local_idx == 0) {
      let sum_final = ${sumVector("workgroup_shared[0][0]", components)} / f32(hight * ${components});
      let squared_sum_final = ${sumVector("workgroup_shared[0][1]", components)} / f32(hight * ${components});

      let inv_std_dev = inverseSqrt(squared_sum_final - sum_final * sum_final + f32(${epsilon}));
      let channel_scale = inv_std_dev * f32(scale[channel]);
      let channel_shift = f32(bias[channel]) - sum_final * channel_scale;
      output[workgroup_index] = vec2f(channel_scale, channel_shift);
    }
  }`;
        };
        return context.compute(
          {
            name: "InstanceNormComputeChannelScaleShift",
            // TODO: use epsilon as uniform. Currently epsilon as uniform fails test_instancenorm_epsilon.
            shaderCache: { hint: `${components};${epsilon};${workgroupSize}`, inputDependencies },
            getRunData: () => ({
              outputs: [{ dims: outputShape, dataType: 1 /* float */ }],
              dispatchGroup: { x: unitsOfWork },
              programUniforms
            }),
            getShaderSource
          },
          { inputs: [input, scale, bias], outputs: [-1] }
        )[0];
      };
      createInstanceNormProgramInfo = (context, inputs, attributes) => {
        const xShape = inputs[0].dims;
        const outputShape = xShape;
        const axis = 2;
        const N = xShape[0];
        const C = xShape[1];
        const H = ShapeUtil.sizeFromDimension(xShape, axis);
        const components = getMaxComponents(H);
        const outputSize = ShapeUtil.size(outputShape) / components;
        const channelScaleShift = computeChannelScaleShift(
          context,
          inputs[0],
          inputs[1],
          inputs[2],
          N,
          H,
          C,
          attributes.epsilon
        );
        const inputShape = [N, C, H / components];
        const scaleShape = [N, C];
        const inputDependencies = ["type", "none"];
        const getShaderSource = (shaderHelper) => {
          const x = inputVariable("x", inputs[0].dataType, inputShape.length, components);
          const scale = inputVariable("scale_shift", 1 /* float */, scaleShape.length, 2);
          const output = outputVariable("output", inputs[0].dataType, inputShape.length, components);
          const variables = [x, scale, output];
          return `
  ${shaderHelper.registerUniform("output_size", "u32").declareVariables(...variables)}
  ${shaderHelper.mainStart()}
  ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
      let outputIndices = ${output.offsetToIndices("global_idx")};
      let batch = outputIndices[0];
      let channel = outputIndices[1];
      let scale_shift = ${scale.getByIndices("vec2<u32>(batch, channel)")};
      let value = ${x.getByOffset("global_idx")} * ${output.type.value}(scale_shift.x) + ${output.type.value}(scale_shift.y);
      ${output.setByOffset("global_idx", "value")};
  }`;
        };
        context.compute(
          {
            name: "InstanceNormalization",
            shaderCache: { hint: `${components}`, inputDependencies },
            getRunData: () => ({
              outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],
              dispatchGroup: { x: Math.ceil(
                outputSize / 64
                /* workgroup size */
              ) },
              programUniforms: [
                { type: 12 /* uint32 */, data: outputSize },
                ...createTensorShapeVariables(inputShape, scaleShape, inputShape)
              ]
            }),
            getShaderSource
          },
          { inputs: [inputs[0], channelScaleShift] }
        );
      };
      createInstanceNormNHWCProgramInfo = (context, inputs, attributes) => {
        const xShape = inputs[0].dims;
        const outputShape = xShape;
        const N = xShape[0];
        const C = xShape[xShape.length - 1];
        const H = ShapeUtil.sizeFromDimension(xShape, 1) / C;
        const components = getMaxComponents(C);
        const outputSize = ShapeUtil.size(outputShape) / components;
        const programUniforms = [
          { type: 12 /* uint32 */, data: H },
          { type: 12 /* uint32 */, data: Math.floor(C / components) }
        ];
        const inputDependencies = ["type", "type"];
        let needTranspose = false;
        const transposedXPerm = [0, xShape.length - 1];
        for (let i = 0; i < xShape.length - 2; i++) {
          needTranspose = needTranspose || xShape[i + 1] !== 1;
          transposedXPerm.push(i + 1);
        }
        needTranspose = needTranspose && xShape[xShape.length - 1] !== 1;
        const transposedX = needTranspose ? context.compute(createTransposeProgramInfo(context.inputs[0], transposedXPerm), {
          inputs: [context.inputs[0]],
          outputs: [-1]
        })[0] : context.inputs[0].reshape(Array.from({ length: xShape.length }, (_, i) => xShape[transposedXPerm[i]]));
        const channelScaleShift = computeChannelScaleShift(
          context,
          transposedX,
          inputs[1],
          inputs[2],
          N,
          H,
          C,
          attributes.epsilon
        );
        const getShaderSource = (shaderHelper) => {
          const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);
          const scaleType = components === 1 ? "vec2f" : `mat${components}x2f`;
          const scaleData = (num) => {
            const index = num === 0 ? "x" : "y";
            const f32Type = components === 1 ? "f32" : `vec${components}f`;
            switch (components) {
              case 1:
                return `${dataType}(${f32Type}(scale.${index}))`;
              case 2:
                return `vec2<${dataType}>(${f32Type}(scale[0].${index}, scale[1].${index}))`;
              case 4:
                return `vec4<${dataType}>(${f32Type}(scale[0].${index}, scale[1].${index}, scale[2].${index}, scale[3].${index}))`;
              default:
                throw new Error(`Not supported compoents ${components}`);
            }
          };
          const inputHelper = inputVariable("input", inputs[0].dataType, inputs[0].dims, components);
          const outputHelper = outputVariable("output", inputs[0].dataType, outputShape, components);
          return `
  @group(0) @binding(0) var<storage, read> input : array<${inputHelper.type.storage}>;
  @group(0) @binding(1) var<storage, read> scale_input : array<${scaleType}>;
  @group(0) @binding(2) var<storage, read_write> output : array<${outputHelper.type.storage}>;
  struct Uniforms {H: u32, C : u32};
  @group(0) @binding(3) var<uniform> uniforms: Uniforms;

  ${shaderHelper.mainStart()}
    let current_image_number = global_idx / (uniforms.C * uniforms.H);
    let current_channel_number = global_idx % uniforms.C;

    let scale_offset = current_image_number * uniforms.C + current_channel_number;
    let scale = scale_input[scale_offset];
    output[global_idx] = fma(input[global_idx], ${scaleData(0)}, ${scaleData(1)});
  }`;
        };
        context.compute(
          {
            name: "InstanceNormalizationNHWC",
            shaderCache: { hint: `${components}`, inputDependencies },
            getRunData: () => ({
              outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],
              dispatchGroup: { x: Math.ceil(
                outputSize / 64
                /* workgroup size */
              ) },
              programUniforms
            }),
            getShaderSource
          },
          { inputs: [inputs[0], channelScaleShift] }
        );
      };
      instanceNorm = (context, attributes) => {
        if (attributes.format === "NHWC") {
          createInstanceNormNHWCProgramInfo(context, context.inputs, attributes);
        } else {
          createInstanceNormProgramInfo(context, context.inputs, attributes);
        }
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/layer-norm.ts
  var validateInputs21, createLayerNormProgramInfo, layerNorm;
  var init_layer_norm = __esm({
    "web/lib/wasm/jsep/webgpu/ops/layer-norm.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_common();
      validateInputs21 = (inputs) => {
        if (!inputs || inputs.length < 2) {
          throw new Error("layerNorm requires at least 2 inputs.");
        }
      };
      createLayerNormProgramInfo = (inputs, attributes, outputCount) => {
        const simplified = attributes.simplified;
        const xShape = inputs[0].dims;
        const scale = inputs[1];
        const bias = !simplified && inputs[2];
        const outputShape = xShape;
        const axis = ShapeUtil.normalizeAxis(attributes.axis, xShape.length);
        const normCount = ShapeUtil.sizeToDimension(xShape, axis);
        const normSize = ShapeUtil.sizeFromDimension(xShape, axis);
        const scaleSize = ShapeUtil.size(scale.dims);
        const biasSize = bias ? ShapeUtil.size(bias.dims) : 0;
        if (scaleSize !== normSize || bias && biasSize !== normSize) {
          throw new Error(`Size of X.shape()[axis:] == ${normSize}.
       Size of scale and bias (if provided) must match this.
       Got scale size of ${scaleSize} and bias size of ${biasSize}`);
        }
        const meanInvStdDevDim = [];
        for (let i = 0; i < xShape.length; ++i) {
          if (i < axis) {
            meanInvStdDevDim.push(xShape[i]);
          } else {
            meanInvStdDevDim.push(1);
          }
        }
        const components = getMaxComponents(normSize);
        const inputDependencies = ["type", "type"];
        const programUniforms = [
          { type: 12 /* uint32 */, data: normCount },
          { type: 1 /* float */, data: normSize },
          { type: 12 /* uint32 */, data: Math.floor(normSize / components) },
          { type: 1 /* float */, data: attributes.epsilon }
        ];
        if (bias) {
          inputDependencies.push("type");
        }
        const hasMeanDataOutput = outputCount > 1;
        const hasInvStdOutput = outputCount > 2;
        const getShaderSource = (shaderHelper) => {
          const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);
          const variables = [
            inputVariable("x", inputs[0].dataType, inputs[0].dims, components),
            inputVariable("scale", scale.dataType, scale.dims, components)
          ];
          if (bias) {
            variables.push(inputVariable("bias", bias.dataType, bias.dims, components));
          }
          variables.push(outputVariable("output", inputs[0].dataType, outputShape, components));
          if (hasMeanDataOutput) {
            variables.push(outputVariable("mean_data_output", 1 /* float */, meanInvStdDevDim));
          }
          if (hasInvStdOutput) {
            variables.push(outputVariable("inv_std_output", 1 /* float */, meanInvStdDevDim));
          }
          const uniforms = [
            { name: "norm_count", type: "u32" },
            { name: "norm_size", type: "f32" },
            { name: "norm_size_vectorized", type: "u32" },
            { name: "epsilon", type: "f32" }
          ];
          return `
  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}
  ${shaderHelper.mainStart()}
    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.norm_count")}
    let offset = global_idx * uniforms.norm_size_vectorized;
    var mean_vector = ${fillVector("f32", components)};
    var mean_square_vector = ${fillVector("f32", components)};

    for (var h: u32 = 0u; h < uniforms.norm_size_vectorized; h++) {
      let value = ${castToF32(dataType, components, "x[h + offset]")};
      mean_vector += value;
      mean_square_vector += value * value;
    }
    let mean = ${sumVector("mean_vector", components)} / uniforms.norm_size;
    let inv_std_dev = inverseSqrt(${sumVector("mean_square_vector", components)} / uniforms.norm_size ${simplified ? "" : "- mean * mean"} + uniforms.epsilon);

    for (var j: u32 = 0; j < uniforms.norm_size_vectorized; j++) {
      let f32input = ${castToF32(dataType, components, "x[j + offset]")};
      let f32scale = ${castToF32(dataType, components, "scale[j]")};
      output[j + offset] = ${variables[0].type.value}((f32input ${simplified ? "" : "- mean"}) * inv_std_dev * f32scale
        ${bias ? `+ ${castToF32(dataType, components, "bias[j]")}` : ""}
      );
    }

    ${hasMeanDataOutput ? "mean_data_output[global_idx] = mean" : ""};
    ${hasInvStdOutput ? "inv_std_output[global_idx] = inv_std_dev" : ""};
  }`;
        };
        const outputs = [{ dims: outputShape, dataType: inputs[0].dataType }];
        if (hasMeanDataOutput) {
          outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ });
        }
        if (hasInvStdOutput) {
          outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ });
        }
        return {
          name: "LayerNormalization",
          shaderCache: { hint: `${components};${outputCount};${simplified}`, inputDependencies },
          getRunData: () => ({
            outputs,
            dispatchGroup: { x: Math.ceil(
              normCount / 64
              /* workgroup size */
            ) },
            programUniforms
          }),
          getShaderSource
        };
      };
      layerNorm = (context, attributes) => {
        validateInputs21(context.inputs);
        context.compute(createLayerNormProgramInfo(context.inputs, attributes, context.outputCount));
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/matmul.ts
  var validateInputs22, matMul;
  var init_matmul = __esm({
    "web/lib/wasm/jsep/webgpu/ops/matmul.ts"() {
      "use strict";
      init_util();
      init_matmul_shaders();
      init_matmul_packed_webgpu();
      validateInputs22 = (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.");
        }
      };
      matMul = (context) => {
        validateInputs22(context.inputs);
        const outputShape = BroadcastUtil.calcShape(context.inputs[0].dims, context.inputs[1].dims, true);
        if (!outputShape) {
          throw new Error("Can't use matmul on the given tensors");
        }
        const N = outputShape[outputShape.length - 1];
        const K = context.inputs[0].dims[context.inputs[0].dims.length - 1];
        if (N < 8 && K < 8) {
          context.compute(createNaiveMatmulProgramInfo(context.inputs, { activation: "" }, outputShape));
        } else {
          const M = outputShape[outputShape.length - 2];
          const batchA = ShapeUtil.size(context.inputs[0].dims.slice(0, -2));
          const batchB = ShapeUtil.size(context.inputs[1].dims.slice(0, -2));
          if (batchA !== 1 && M === 1 && batchB === 1) {
            const reshapedA = context.inputs[0].reshape([1, batchA, K]);
            const reshapedB = context.inputs[1].reshape([1, K, N]);
            const matmulOutputShape = [1, batchA, N];
            const matmulInputs = [reshapedA, reshapedB];
            context.compute(createMatmulProgramInfo(matmulInputs, { activation: "" }, outputShape, matmulOutputShape), {
              inputs: matmulInputs
            });
          } else {
            context.compute(createMatmulProgramInfo(context.inputs, { activation: "" }, outputShape));
          }
        }
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/matmulnbits.ts
  var validateInputs23, createMatMulNBitsProgramInfo, createMatMulNBitsBlockSize32ProgramInfo, matMulNBits, parseMatMulNBitsAttributes;
  var init_matmulnbits = __esm({
    "web/lib/wasm/jsep/webgpu/ops/matmulnbits.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      validateInputs23 = (inputs, attributes) => {
        if (inputs.length < 3 || inputs.length > 4) {
          throw new Error("MatMulNBits requires 3 or 4 inputs");
        }
        const a = inputs[0];
        const aRank = a.dims.length;
        if (a.dims[aRank - 1] !== attributes.k) {
          throw new Error("The last dim of input shape does not match the k value");
        }
        const nBlocksPerCol = Math.floor((attributes.k + attributes.blockSize - 1) / attributes.blockSize);
        const blobSize = attributes.blockSize / 8 * attributes.bits;
        const b = inputs[1];
        if (!ShapeUtil.areEqual(b.dims, [attributes.n, nBlocksPerCol, blobSize])) {
          throw new Error("The second inputs must be 3D tensor with shape N X nBlocksPerCol X blobSize");
        }
        const scales = inputs[2];
        const scalesShape = scales.dims;
        if (ShapeUtil.size(scalesShape) !== attributes.n * nBlocksPerCol) {
          throw new Error("scales input size error.");
        }
        if (inputs.length === 4) {
          const zeroPoints = inputs[3];
          const zeroPointsShape = zeroPoints.dims;
          const expectedZeroPointsSize = attributes.n * (attributes.bits === 8 ? nBlocksPerCol : Math.floor((nBlocksPerCol * attributes.bits + 7) / 8));
          if (ShapeUtil.size(zeroPointsShape) !== expectedZeroPointsSize) {
            throw new Error("zeroPoints input size error.");
          }
        }
      };
      createMatMulNBitsProgramInfo = (inputs, attributes) => {
        const inputShape = inputs[0].dims;
        const aRank = inputShape.length;
        const dimAOuter = inputShape[aRank - 2];
        const dimInner = attributes.k;
        const dimBOuter = attributes.n;
        const batchDims = inputShape.slice(0, aRank - 2);
        const batchSize = ShapeUtil.size(batchDims);
        const blobSize = inputs[1].dims[2];
        const blobSizeInWords = blobSize / 4;
        const dataType = inputs[0].dataType;
        const aComponents = getMaxComponents(attributes.k);
        const bComponents = getMaxComponents(blobSizeInWords);
        const components = getMaxComponents(dimBOuter);
        const outputShape = batchDims.concat([dimAOuter, dimBOuter]);
        const outputNumber = dimAOuter > 1 && dimBOuter / components % 2 === 0 ? 2 : 1;
        const dispatchSize = ShapeUtil.size(outputShape) / components / outputNumber;
        const workgroupSize = 64;
        const programUniforms = [];
        const inputShapeTemp = [batchSize, dimAOuter, dimInner / aComponents];
        const bShape = ShapeUtil.convertShape(inputs[1].dims).slice();
        bShape.splice(-1, 1, blobSizeInWords / bComponents);
        programUniforms.push(...createTensorShapeVariables(inputShapeTemp));
        programUniforms.push(...createTensorShapeVariables(bShape));
        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));
        if (inputs.length === 4) {
          programUniforms.push(...createTensorShapeVariables(ShapeUtil.convertShape(inputs[3].dims)));
        }
        const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components];
        programUniforms.push(...createTensorShapeVariables(outputShapeTemp));
        const getShaderSource = (shaderHelper) => {
          const inputRank = inputShapeTemp.length;
          const a = inputVariable("a", inputs[0].dataType, inputRank, aComponents);
          const b = inputVariable("b", 12 /* uint32 */, bShape.length, bComponents);
          const scales = inputVariable("scales", inputs[2].dataType, inputs[2].dims.length);
          const inputVariables = [a, b, scales];
          const zeroPoints = inputs.length === 4 ? inputVariable("zero_points", 12 /* uint32 */, inputs[3].dims.length) : void 0;
          if (zeroPoints) {
            inputVariables.push(zeroPoints);
          }
          const outputRank = outputShapeTemp.length;
          const output = outputVariable("output", inputs[0].dataType, outputRank, components);
          const dataType2 = tensorTypeToWsglStorageType(inputs[0].dataType);
          const qDqDataType = (() => {
            switch (aComponents) {
              case 1:
                return `array<${dataType2}, 8>`;
              case 2:
                return `mat4x2<${dataType2}>`;
              case 4:
                return `mat2x4<${dataType2}>`;
              default:
                throw new Error(`${aComponents}-component is not supported.`);
            }
          })();
          const valuesPerWord = Math.floor(32 / attributes.bits);
          const passesPerWord = Math.floor(valuesPerWord / 8);
          const processOneWord = () => {
            let calcStr = "";
            for (let pass = 0; pass < passesPerWord; pass++) {
              const lowerShift = pass * attributes.bits * 4;
              const upperShift = lowerShift + attributes.bits;
              calcStr += `
          // reuse a data (pass ${pass})
            var input_offset${pass > 0 ? pass : ""} = ${pass === 0 ? a.indicesToOffset(`${a.type.indices}(batch, row, word_offset)`) : `input_offset`};
            var a_data${pass > 0 ? pass : ""}: ${qDqDataType};
            for (var j${pass > 0 ? pass : ""}: u32 = 0; j${pass > 0 ? pass : ""} < ${8 / aComponents}; j${pass > 0 ? pass : ""}++) {
              a_data${pass > 0 ? pass : ""}[j${pass > 0 ? pass : ""}] = ${a.getByOffset(`input_offset${pass > 0 ? pass : ""}`)};
              input_offset${pass > 0 ? pass : ""}++;
            }
          `;
              for (let c = 0; c < components * outputNumber; c++) {
                calcStr += `
            b_value = ${bComponents === 1 ? `b${c}_data` : `b${c}_data[i]`};
            ${attributes.bits === 2 ? `{
              let half_word = b_value >> ${pass * 16}u;
              let byte_lo = half_word & 0xFFu;
              let byte_hi = (half_word >> 8u) & 0xFFu;
              let spread_word = (byte_lo & 0xFu) | ((byte_lo >> 4u) << 8u) | ((byte_hi & 0xFu) << 16u) | ((byte_hi >> 4u) << 24u);
              b_value_lower = unpack4xU8(spread_word & b_mask);
              b_value_upper = unpack4xU8((spread_word >> 2u) & b_mask);
            }` : `b_value_lower = unpack4xU8((b_value >> ${lowerShift}u) & b_mask);
            b_value_upper = unpack4xU8((b_value >> ${upperShift}u) & b_mask);`}
            b_quantized_values = ${qDqDataType}(${Array.from(
                  { length: 4 },
                  (_, i) => `${dataType2}(b_value_lower[${i}]), ${dataType2}(b_value_upper[${i}])`
                ).join(", ")});
            b_dequantized_values = ${(() => {
                  if (aComponents === 1) {
                    return `${qDqDataType}(${Array.from(
                      { length: 8 },
                      (_, i) => `(b_quantized_values[${i}] - ${zeroPoints ? `zero_point${c}` : "zero_point"}) * scale${c}`
                    ).join(", ")});`;
                  } else {
                    return `(b_quantized_values - ${qDqDataType}(${Array(8).fill(`${zeroPoints ? `zero_point${c}` : "zero_point"}`).join(",")})) * scale${c};`;
                  }
                })()};
            workgroup_shared[local_id.x * ${outputNumber} + ${Math.floor(c / components)}]${components > 1 ? `[${c % components}]` : ""} += ${Array.from(
                  { length: 8 / aComponents },
                  (_, i) => `${aComponents === 1 ? `a_data${pass > 0 ? pass : ""}[${i}] * b_dequantized_values[${i}]` : `dot(a_data${pass > 0 ? pass : ""}[${i}], b_dequantized_values[${i}])`}`
                ).join(" + ")};
          `;
              }
            }
            return calcStr;
          };
          const prepareScaleAndZeroPoint = () => {
            let calcStr = `
            var col_index = col * ${components};
            ${zeroPoints ? `
            let zero_point_values_per_byte: u32 = ${Math.floor(8 / attributes.bits)}u;
            let zero_point_bytes_per_col = (nBlocksPerCol + zero_point_values_per_byte - 1u) / zero_point_values_per_byte;
            var zero_point_byte_count: u32;
            var zero_point_word_index: u32;
            var zero_point_byte_offset: u32;
            let zero_point_sub_offset: u32 = block % zero_point_values_per_byte;
            var zero_point_bits_offset: u32;
            var zero_point_word: u32;` : `
            // The default zero point is ${Math.pow(2, attributes.bits - 1)} for unsigned ${attributes.bits}-bit quantization.
            let zero_point = ${dataType2}(${Math.pow(2, attributes.bits - 1).toFixed(1)});`}
            `;
            for (let c = 0; c < components * outputNumber; c++) {
              calcStr += `
            let scale${c} = ${scales.getByOffset(`col_index * nBlocksPerCol + block`)};
            ${zeroPoints ? `
            zero_point_byte_count = col_index * zero_point_bytes_per_col + (block / zero_point_values_per_byte);
            zero_point_word_index = zero_point_byte_count >> 0x2u;
            zero_point_byte_offset = zero_point_byte_count & 0x3u;
            zero_point_bits_offset = (zero_point_byte_offset << 3) + (zero_point_sub_offset * ${attributes.bits}u);
            zero_point_word = ${zeroPoints.getByOffset("zero_point_word_index")} >> zero_point_bits_offset;
            let zero_point${c} = ${dataType2}((zero_point_word) & ${attributes.bits === 2 ? "0x3u" : "0xFu"});` : ""}
            col_index += 1;`;
            }
            return calcStr;
          };
          const prepareBData = () => {
            let calcStr = `col_index = col * ${components};`;
            for (let c = 0; c < components * outputNumber; c++) {
              calcStr += `
            let b${c}_data = ${b.getByIndices(`${b.type.indices}(col_index, block, word)`)};
            col_index += 1;`;
            }
            calcStr += `
            var b_value: u32;
            let b_mask: u32 = ${attributes.bits === 2 ? "0x03030303u" : "0x0F0F0F0Fu"};
            var b_value_lower: vec4<u32>;
            var b_value_upper: vec4<u32>;
            var b_quantized_values: ${qDqDataType};
            var b_dequantized_values: ${qDqDataType};`;
            return calcStr;
          };
          return `
        var<workgroup> workgroup_shared: array<${output.type.value}, ${outputNumber * workgroupSize}>;
        ${shaderHelper.declareVariables(...inputVariables, output)}
        ${shaderHelper.mainStart([workgroupSize, 1, 1])}
          let output_indices = ${output.offsetToIndices(`(global_idx / ${workgroupSize}) * ${outputNumber}`)};
          let col = output_indices[2];
          let row = output_indices[1];
          let batch = output_indices[0];
          let nBlocksPerCol = uniforms.b_shape[1];

          for (var block = local_id.x; block < nBlocksPerCol; block += ${workgroupSize}) {
            //process one block
            var word_offset: u32 = block * ${attributes.blockSize / aComponents};
            ${prepareScaleAndZeroPoint()}
            for (var word: u32 = 0; word < ${blobSizeInWords}; word += ${bComponents}) {
              ${prepareBData()}
              for (var i: u32 = 0; i < ${bComponents}; i++) {
                ${processOneWord()}
                word_offset += ${valuesPerWord / aComponents};
              }
            }
          }
          workgroupBarrier();

          if (local_id.x < ${outputNumber}) {
            var output_value: ${output.type.value} = ${output.type.value}(0);
            var workgroup_shared_offset: u32 = local_id.x;
            for (var b: u32 = 0u; b < ${workgroupSize}u; b++) {
              output_value += workgroup_shared[workgroup_shared_offset];
              workgroup_shared_offset += ${outputNumber};
            }
            ${output.setByIndices(`${output.type.indices}(batch, row, col + local_id.x)`, "output_value")};
          }
        }`;
        };
        return {
          name: "MatMulNBits",
          shaderCache: {
            hint: `${attributes.blockSize};${attributes.bits};${aComponents};${bComponents};${components};${outputNumber};${workgroupSize}`,
            inputDependencies: Array(inputs.length).fill("rank")
          },
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType }],
            dispatchGroup: { x: dispatchSize },
            programUniforms
          }),
          getShaderSource
        };
      };
      createMatMulNBitsBlockSize32ProgramInfo = (inputs, attributes) => {
        const inputShape = inputs[0].dims;
        const aRank = inputShape.length;
        const dimAOuter = inputShape[aRank - 2];
        const dimInner = attributes.k;
        const dimBOuter = attributes.n;
        const batchDims = inputShape.slice(0, aRank - 2);
        const batchSize = ShapeUtil.size(batchDims);
        const blobSize = inputs[1].dims[2];
        const blobSizeInWords = blobSize / 4;
        const dataType = inputs[0].dataType;
        const aComponents = getMaxComponents(attributes.k);
        const bComponents = getMaxComponents(blobSizeInWords);
        const outputShape = batchDims.concat([dimAOuter, dimBOuter]);
        const workgroupSize = 128;
        const workgroupY = dimBOuter % 8 === 0 ? 8 : dimBOuter % 4 === 0 ? 4 : 1;
        const workgroupX = workgroupSize / workgroupY;
        const valuesPerWordBs32 = Math.floor(32 / attributes.bits);
        const tileSize = workgroupX * bComponents * valuesPerWordBs32;
        const aLengthPerTile = tileSize / aComponents;
        const blocksPerTile = tileSize / attributes.blockSize;
        const dispatchSize = ShapeUtil.size(outputShape) / workgroupY;
        const programUniforms = [];
        const inputShapeTemp = [batchSize, dimAOuter, dimInner / aComponents];
        const bShape = ShapeUtil.convertShape(inputs[1].dims).slice();
        bShape.splice(-1, 1, blobSizeInWords / bComponents);
        programUniforms.push(...createTensorShapeVariables(inputShapeTemp));
        programUniforms.push(...createTensorShapeVariables(bShape));
        programUniforms.push(...createTensorShapeVariables(inputs[2].dims));
        if (inputs.length === 4) {
          programUniforms.push(...createTensorShapeVariables(ShapeUtil.convertShape(inputs[3].dims)));
        }
        const outputShapeTemp = [batchSize, dimAOuter, dimBOuter];
        programUniforms.push(...createTensorShapeVariables(outputShapeTemp));
        const getShaderSource = (shaderHelper) => {
          const inputRank = inputShapeTemp.length;
          const a = inputVariable("a", inputs[0].dataType, inputRank, aComponents);
          const b = inputVariable("b", 12 /* uint32 */, bShape.length, bComponents);
          const scales = inputVariable("scales", inputs[2].dataType, inputs[2].dims.length);
          const inputVariables = [a, b, scales];
          const zeroPoints = inputs.length === 4 ? inputVariable("zero_points", 12 /* uint32 */, inputs[3].dims.length) : void 0;
          if (zeroPoints) {
            inputVariables.push(zeroPoints);
          }
          const outputRank = outputShapeTemp.length;
          const output = outputVariable("output", inputs[0].dataType, outputRank);
          const dataType2 = tensorTypeToWsglStorageType(inputs[0].dataType);
          const readA = () => {
            switch (aComponents) {
              case 1:
                return `
          let a_data0 = vec4<${dataType2}>(sub_a[word_offset], sub_a[word_offset + 1], sub_a[word_offset + 2], sub_a[word_offset + 3]);
          let a_data1 = vec4<${dataType2}>(sub_a[word_offset + 4], sub_a[word_offset + 5], sub_a[word_offset + 6], sub_a[word_offset + 7]);`;
              case 2:
                return `
          let a_data0 = vec4<${dataType2}>(sub_a[word_offset], sub_a[word_offset + 1]);
          let a_data1 = vec4<${dataType2}>(sub_a[word_offset + 2], sub_a[word_offset + 3]);`;
              case 4:
                return `
          let a_data0 = sub_a[word_offset];
          let a_data1 = sub_a[word_offset + 1];`;
              default:
                throw new Error(`${aComponents}-component is not supported.`);
            }
          };
          return `
        var<workgroup> sub_a: array<${a.type.value}, ${aLengthPerTile}>;
        var<workgroup> inter_results: array<array<${output.type.value}, ${workgroupX}>, ${workgroupY}>;
        ${shaderHelper.declareVariables(...inputVariables, output)}
        ${shaderHelper.mainStart([workgroupX, workgroupY, 1])}
          let output_indices = ${output.offsetToIndices(`workgroup_index * ${workgroupY}`)};
          let col = output_indices[2];
          let row = output_indices[1];
          let batch = output_indices[0];
          let n_blocks_per_col = uniforms.b_shape[1];
          let num_tiles =  (n_blocks_per_col - 1) / ${blocksPerTile} + 1;

          // Loop over shared dimension.
          for (var tile: u32 = 0; tile < num_tiles; tile += 1) {
            let a_col_start = tile * ${aLengthPerTile};
            // load one tile A data into shared memory.
            for (var a_offset = local_idx; a_offset < ${aLengthPerTile}; a_offset += ${workgroupSize})
            {
              let a_col = a_col_start + a_offset;
              if (a_col < uniforms.a_shape[2])
              {
                sub_a[a_offset] = ${a.getByIndices(`${a.type.indices}(batch, row, a_col)`)};
              } else {
                sub_a[a_offset] = ${a.type.value}(0);
              }
            }
            workgroupBarrier();

            // each thread process one block
            let b_row = col + local_id.y;
            let block = tile * ${blocksPerTile} + local_id.x;
            ${zeroPoints ? `
            let zero_point_values_per_byte: u32 = ${Math.floor(8 / attributes.bits)}u;
            let zero_point_bytes_per_col = (n_blocks_per_col + zero_point_values_per_byte - 1u) / zero_point_values_per_byte;
            let zero_point_byte_count = b_row * zero_point_bytes_per_col + (block / zero_point_values_per_byte);
            let zero_point_word_index = zero_point_byte_count >> 0x2u;
            let zero_point_byte_offset = zero_point_byte_count & 0x3u;
            let zero_point_sub_offset: u32 = block % zero_point_values_per_byte;
            let zero_point_bits_offset = (zero_point_byte_offset << 3) + (zero_point_sub_offset * ${attributes.bits}u);
            let zero_point_word = ${zeroPoints.getByOffset("zero_point_word_index")} >> zero_point_bits_offset;
            let zero_point = ${dataType2}((zero_point_word) & ${attributes.bits === 2 ? "0x3u" : "0xFu"});` : `
            // The default zero point is ${Math.pow(2, attributes.bits - 1)} for unsigned ${attributes.bits}-bit quantization.
            let zero_point = ${dataType2}(${Math.pow(2, attributes.bits - 1).toFixed(1)});`}
            let scale = ${scales.getByOffset(`b_row * n_blocks_per_col + block`)};
            let b_data = ${b.getByIndices(`${b.type.indices}(b_row, block, 0)`)};
            var word_offset = local_id.x * ${attributes.blockSize / aComponents};
            for (var i: u32 = 0; i < ${bComponents}; i++) {
              let b_value = ${bComponents === 1 ? `b_data` : `b_data[i]`};
              ${(() => {
            const passesPerWordBs32 = Math.floor(valuesPerWordBs32 / 8);
            let code = "";
            for (let pass = 0; pass < passesPerWordBs32; pass++) {
              const lowerShift = pass * attributes.bits * 4;
              const upperShift = lowerShift + attributes.bits;
              code += `
              ${readA()}
              {${attributes.bits === 2 ? `
                let half_word = b_value >> ${pass * 16}u;
                let byte_lo = half_word & 0xFFu;
                let byte_hi = (half_word >> 8u) & 0xFFu;
                let spread_word = (byte_lo & 0xFu) | ((byte_lo >> 4u) << 8u) | ((byte_hi & 0xFu) << 16u) | ((byte_hi >> 4u) << 24u);
                let b_value_lower = unpack4xU8(spread_word & 0x03030303u);
                let b_value_upper = unpack4xU8((spread_word >> 2u) & 0x03030303u);` : `
                let b_value_lower = unpack4xU8((b_value >> ${lowerShift}u) & 0x0F0F0F0Fu);
                let b_value_upper = unpack4xU8((b_value >> ${upperShift}u) & 0x0F0F0F0Fu);`}
                let b_quantized_values = mat2x4<${dataType2}>(${Array.from(
                { length: 4 },
                (_, i) => `${dataType2}(b_value_lower[${i}]), ${dataType2}(b_value_upper[${i}])`
              ).join(", ")});
                let b_dequantized_values = (b_quantized_values - mat2x4<${dataType2}>(${Array(8).fill("zero_point").join(",")})) * scale;
                inter_results[local_id.y][local_id.x] += ${Array.from(
                { length: 2 },
                (_, i) => `${`dot(a_data${i}, b_dequantized_values[${i}])`}`
              ).join(" + ")};
              }
              word_offset += ${8 / aComponents};`;
            }
            return code;
          })()}
            }
            workgroupBarrier();
          }

          if (local_idx < ${workgroupY}) {
            var output_value: ${output.type.value} = ${output.type.value}(0);
            for (var b = 0u; b < ${workgroupX}; b++) {
              output_value += inter_results[local_idx][b];
            }
            if (col + local_idx < uniforms.output_shape[2])
            {
              ${output.setByIndices(`${output.type.indices}(batch, row, col + local_idx)`, "output_value")}
            }
          }
        }`;
        };
        return {
          name: "BlockwiseMatMulNBits32",
          shaderCache: {
            hint: `${attributes.blockSize};${aComponents};${bComponents};${workgroupX};${workgroupY}`,
            inputDependencies: Array(inputs.length).fill("rank")
          },
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType }],
            dispatchGroup: { x: dispatchSize },
            programUniforms
          }),
          getShaderSource
        };
      };
      matMulNBits = (context, attributes) => {
        validateInputs23(context.inputs, attributes);
        if (attributes.blockSize === 32 && context.adapterInfo.isVendor("intel") && context.adapterInfo.isArchitecture("gen-12lp")) {
          context.compute(createMatMulNBitsBlockSize32ProgramInfo(context.inputs, attributes));
        } else {
          context.compute(createMatMulNBitsProgramInfo(context.inputs, attributes));
        }
      };
      parseMatMulNBitsAttributes = (attributes) => createAttributeWithCacheKey(attributes);
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/pad.ts
  var validateInputs24, getPadConstant, getPadReflect, getPadEdge, getPadWrap, getPadSnippet, createPadProgramInfo, createPadAttributesFromInputs, pad;
  var init_pad = __esm({
    "web/lib/wasm/jsep/webgpu/ops/pad.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_common();
      validateInputs24 = (inputs) => {
        if (!inputs || inputs.length < 1) {
          throw new Error("Too few inputs");
        }
        if (inputs[0].dataType !== 1 /* float */ && inputs[0].dataType !== 10 /* float16 */) {
          throw new Error("Input type must be float or float16.");
        }
        if (inputs.length >= 2) {
          let validPads = inputs[0].dims.length * 2 === inputs[1].dims[0];
          if (inputs.length === 4) {
            validPads = inputs[3].dims[0] * 2 === inputs[1].dims[0];
          }
          if (!validPads) {
            throw new Error("The pads should be a 1D tensor of shape [2 * input_rank] or [2 * num_axes].");
          }
        }
      };
      getPadConstant = (output, inputRank, padsLength) => {
        let block = "";
        for (let i = inputRank - 1; i >= 0; --i) {
          block += `
            k = i32(${output.indicesGet("indices", i)}) - ${getElementAt("uniforms.pads", i, padsLength)};
            if (k < 0) {
              break;
            }
            if (k >= i32(${getElementAt("uniforms.x_shape", i, inputRank)})) {
              break;
            }
            offset += k * i32(${getElementAt("uniforms.x_strides", i, inputRank)});
        `;
        }
        return `
          value = ${output.type.value}(uniforms.constant_value);
          for (var i = 0; i < 1; i++) {
            var offset = 0;
            var k = 0;
            ${block}
            value = x[offset];
          }
      `;
      };
      getPadReflect = (output, inputRank, padsLength) => {
        let block = "";
        for (let i = inputRank - 1; i >= 0; --i) {
          block += `
                k = i32(${output.indicesGet("indices", i)}) - ${getElementAt("uniforms.pads", i, padsLength)};
                if (k < 0) {
                  k = -k;
                }
                {
                  let _2n_1 = 2 * (i32(${getElementAt("uniforms.x_shape", i, inputRank)}) - 1);
                  k = k % _2n_1;
                  if(k >= i32(${getElementAt("uniforms.x_shape", i, inputRank)})) {
                    k = _2n_1 - k;
                  }
                }
                offset += k * i32(${getElementAt("uniforms.x_strides", i, inputRank)});
            `;
        }
        return `
              var offset = 0;
              var k = 0;
              ${block}
              value = x[offset];
          `;
      };
      getPadEdge = (output, inputRank, padsLength) => {
        let block = "";
        for (let i = inputRank - 1; i >= 0; --i) {
          block += `
                k = i32(${output.indicesGet("indices", i)}) - ${getElementAt("uniforms.pads", i, padsLength)};
                if (k < 0) {
                  k = 0;
                }
                if (k >= i32(${getElementAt("uniforms.x_shape", i, inputRank)})) {
                  k = i32(${getElementAt("uniforms.x_shape", i, inputRank)}) - 1;
                }
                offset += k * i32(${getElementAt("uniforms.x_strides", i, inputRank)});
            `;
        }
        return `
              var offset = 0;
              var k = 0;
              ${block}
              value = x[offset];
          `;
      };
      getPadWrap = (output, inputRank, padsLength) => {
        let block = "";
        for (let i = inputRank - 1; i >= 0; --i) {
          block += `
                k = i32(${output.indicesGet("indices", i)}) - ${getElementAt("uniforms.pads", i, padsLength)};
                if (k < 0)  {
                  k += i32(${getElementAt("uniforms.x_shape", i, inputRank)}]);
                }
                if (k >= i32(${getElementAt("uniforms.x_shape", i, inputRank)})) {
                  k -= i32(${getElementAt("uniforms.x_shape", i, inputRank)});
                }
                offset += k * i32(${getElementAt("uniforms.x_strides", i, inputRank)});
            `;
        }
        return `
              var offset = 0;
              var k = 0;
              ${block}
              value = x[offset];
          `;
      };
      getPadSnippet = (output, inputRank, attributes) => {
        switch (attributes.mode) {
          case 0:
            return getPadConstant(output, inputRank, attributes.pads.length);
          case 1:
            return getPadReflect(output, inputRank, attributes.pads.length);
          case 2:
            return getPadEdge(output, inputRank, attributes.pads.length);
          case 3:
            return getPadWrap(output, inputRank, attributes.pads.length);
          default:
            throw new Error("Invalid mode");
        }
      };
      createPadProgramInfo = (inputs, attributes) => {
        const outputShape = ShapeUtil.padShape(inputs[0].dims.slice(), attributes.pads);
        const inputDims = inputs[0].dims;
        const outputSize = ShapeUtil.size(outputShape);
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 6 /* int32 */, data: attributes.pads }
        ];
        const isValueFromInput = inputs.length >= 3 && inputs[2].data;
        if (attributes.mode === 0) {
          programUniforms.push({ type: isValueFromInput ? inputs[2].dataType : 1 /* float */, data: attributes.value });
        }
        programUniforms.push(...createTensorShapeVariables(inputs[0].dims, outputShape));
        const inputDependencies = ["rank"];
        const getShaderSource = (shaderHelper) => {
          const output = outputVariable("output", inputs[0].dataType, outputShape.length);
          const input = inputVariable("x", inputs[0].dataType, inputDims.length);
          const dataType = input.type.value;
          const padSnippet = getPadSnippet(output, inputDims.length, attributes);
          const uniforms = [
            { name: "output_size", type: "u32" },
            { name: "pads", type: "i32", length: attributes.pads.length }
          ];
          if (attributes.mode === 0) {
            uniforms.push({ name: "constant_value", type: isValueFromInput ? dataType : "f32" });
          }
          return `
            ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}
            ${shaderHelper.mainStart()}
            ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}

            let indices = ${output.offsetToIndices("global_idx")};

            var value = ${dataType}(0);
            ${padSnippet}
            output[global_idx] = value;
        }`;
        };
        return {
          name: "Pad",
          shaderCache: { hint: `${attributes.mode}${isValueFromInput}`, inputDependencies },
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],
            dispatchGroup: { x: Math.ceil(
              ShapeUtil.size(outputShape) / 64
              /* workgroup size */
            ) },
            programUniforms
          }),
          getShaderSource
        };
      };
      createPadAttributesFromInputs = (inputs, attributes) => {
        if (inputs.length > 1) {
          const bigInt64Pads = inputs[1].getBigInt64Array();
          const value = inputs.length >= 3 && inputs[2].data ? inputs[2].dataType === 10 /* float16 */ ? inputs[2].getUint16Array()[0] : inputs[2].getFloat32Array()[0] : 0;
          const inputRank = inputs[0].dims.length;
          const updatePads = new Int32Array(2 * inputRank).fill(0);
          if (inputs.length >= 4) {
            const axes = inputs[3].getBigInt64Array();
            for (let i = 0; i < axes.length; i++) {
              updatePads[Number(axes[i])] = Number(bigInt64Pads[i]);
              updatePads[Number(axes[i]) + inputRank] = Number(bigInt64Pads[i + axes.length]);
            }
          } else {
            bigInt64Pads.forEach((v, i) => updatePads[Number(i)] = Number(v));
          }
          const pads = [];
          updatePads.forEach((v) => pads.push(v));
          return { mode: attributes.mode, value, pads };
        } else {
          return attributes;
        }
      };
      pad = (context, attributes) => {
        validateInputs24(context.inputs);
        const updatedAttributes = createPadAttributesFromInputs(context.inputs, attributes);
        context.compute(createPadProgramInfo(context.inputs, updatedAttributes), { inputs: [0] });
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/pool.ts
  var validateInputs25, getAdjustedPoolAttributesAndOutputShape, getUniformAndPadInfo, generatePoolingCode, createShaderKeyFromAttributes, createAveragePoolShaderKeyFromAttributes, createMaxPoolShaderKeyFromAttributes, parsePoolCommonAttributes, createAveragePoolProgramInfo, parseAveragePoolAttributes, averagePool, globalPoolAttributes, parseGlobalAveragePoolAttributes, globalAveragePool, createMaxPoolProgramInfo, maxPool, parseMaxPoolAttributes, parseGlobalMaxPoolAttributes, globalMaxPool;
  var init_pool = __esm({
    "web/lib/wasm/jsep/webgpu/ops/pool.ts"() {
      "use strict";
      init_esm();
      init_wasm_common();
      init_util();
      init_common();
      validateInputs25 = (inputs) => {
        if (env2.webgpu.validateInputContent && (!inputs || inputs.length !== 1)) {
          throw new Error("Pool ops requires 1 input.");
        }
      };
      getAdjustedPoolAttributesAndOutputShape = (input, attributes, isGlobalOperator) => {
        const isChannelsLast = attributes.format === "NHWC";
        const inputShapeAsChannelFirst = input.dims.slice();
        if (isChannelsLast) {
          inputShapeAsChannelFirst.splice(1, 0, inputShapeAsChannelFirst.pop());
        }
        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, inputShapeAsChannelFirst, kernelShape, strides, dilations, pads);
        const outputShapeAsChannelFirst = PoolConvUtil.computePoolOutputShape(
          isGlobalOperator,
          inputShapeAsChannelFirst,
          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 });
        }
        const outputShapeAsChannelLast = outputShapeAsChannelFirst.slice();
        outputShapeAsChannelLast.push(outputShapeAsChannelLast.splice(1, 1)[0]);
        return [newAttributes, isChannelsLast ? outputShapeAsChannelLast : outputShapeAsChannelFirst];
      };
      getUniformAndPadInfo = (outputShape, attributes) => {
        const isChannelsLast = attributes.format === "NHWC";
        const outputSize = ShapeUtil.size(outputShape);
        const kernelSize = ShapeUtil.size(attributes.kernelShape);
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 12 /* uint32 */, data: kernelSize }
        ];
        const uniforms = [
          { name: "outputSize", type: "u32" },
          { name: "kernelSize", type: "u32" }
        ];
        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 pwStartEndNotZero = !!(pwStart + pwEnd);
          programUniforms.push(
            { type: 12 /* uint32 */, data: kw },
            { type: 12 /* uint32 */, data: sw },
            { type: 12 /* uint32 */, data: pwStart },
            { type: 12 /* uint32 */, data: pwEnd }
          );
          uniforms.push(
            { name: "kw", type: "u32" },
            { name: "sw", type: "u32" },
            { name: "pwStart", type: "u32" },
            { name: "pwEnd", type: "u32" }
          );
          let phStartEndNotZero = false;
          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];
            phStartEndNotZero = !!(phStart + phEnd);
            programUniforms.push(
              { type: 12 /* uint32 */, data: kh },
              { type: 12 /* uint32 */, data: sh },
              { type: 12 /* uint32 */, data: phStart },
              { type: 12 /* uint32 */, data: phEnd }
            );
            uniforms.push(
              { name: "kh", type: "u32" },
              { name: "sh", type: "u32" },
              { name: "phStart", type: "u32" },
              { name: "phEnd", type: "u32" }
            );
          }
          return [programUniforms, uniforms, true, pwStartEndNotZero, phStartEndNotZero];
        } else {
          if (isChannelsLast) {
            throw new Error("Pooling with kernelShape.length > 2 is not supported for NHWC format.");
          }
          const kernelStrides = ShapeUtil.computeStrides(attributes.kernelShape);
          programUniforms.push(
            { type: 12 /* uint32 */, data: kernelStrides },
            { type: 12 /* uint32 */, data: attributes.pads },
            { type: 12 /* uint32 */, data: attributes.strides }
          );
          uniforms.push(
            { name: "kernelStrides", type: "u32", length: kernelStrides.length },
            { name: "pads", type: "u32", length: attributes.pads.length },
            { name: "strides", type: "u32", length: attributes.strides.length }
          );
          const hasPads = attributes.pads.reduce((sum, cur) => sum + cur);
          return [programUniforms, uniforms, !!hasPads, false, false];
        }
      };
      generatePoolingCode = (shaderHelper, x, rank, outputShapeRank, attributes, op1, op2, start, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero) => {
        const isChannelsLast = attributes.format === "NHWC";
        const dataType = x.type.value;
        const output = outputVariable("output", x.type.tensor, outputShapeRank);
        if (attributes.kernelShape.length <= 2) {
          let codeW = "";
          let codeH = "";
          let codeHEnd = "";
          const dimIdxW = rank - (isChannelsLast ? 2 : 1);
          if (pwStartEndNotZero) {
            codeW = `
                for (var i: u32 = 0u; i < uniforms.kw; i++) {
                  xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i;
                  if (xIndices[${dimIdxW}] < 0 || xIndices[${dimIdxW}]
                      >= uniforms.x_shape[${dimIdxW}]) {
                    pad++;
                    continue;
                  }
                  let x_val = x[${x.indicesToOffset("xIndices")}];
                  ${op1}
                }`;
          } else {
            codeW = `
                for (var i: u32 = 0u; i < uniforms.kw; i++) {
                  xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i;
                  let x_val = x[${x.indicesToOffset("xIndices")}];
                  ${op1}
                }`;
          }
          if (attributes.kernelShape.length === 2) {
            const dimIdxH = rank - (isChannelsLast ? 3 : 2);
            if (phStartEndNotZero) {
              codeH = `
                for (var j: u32 = 0u; j < uniforms.kh; j++) {
                  xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j;
                  if (xIndices[${dimIdxH}] < 0 || xIndices[${dimIdxH}] >= uniforms.x_shape[${dimIdxH}]) {
                    pad += i32(uniforms.kw);
                    continue;
                  }
              `;
            } else {
              codeH = `
                for (var j: u32 = 0u; j < uniforms.kh; j++) {
                  xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j;
                `;
            }
            codeHEnd = `
              }
            `;
          }
          const poolingCode = `
            ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)}

            ${shaderHelper.mainStart()}
              ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}

              let indices = ${output.offsetToIndices("global_idx")};
              var xIndices = ${output.offsetToIndices("global_idx")};

              var value = ${dataType}(${start});
              var pad = 0;
              ${codeH}
              ${codeW}
              ${codeHEnd}
              ${op2}

              output[global_idx] = value;
            }`;
          return poolingCode;
        } else {
          if (isChannelsLast) {
            throw new Error("Pooling with kernelShape.length > 2 is not supported for NHWC format.");
          }
          const stridesRank = attributes.kernelShape.length;
          const padsRank = attributes.pads.length;
          let padCode = "";
          if (hasPads) {
            padCode = `
                if (xIndices[j] >= uniforms.x_shape[j]) {
                  pad++;
                  isPad = true;
                  break;
                }
              }
              if (!isPad) {
                let x_val = x[${x.indicesToOffset("xIndices")}];
                ${op1}
              }`;
          } else {
            padCode = `
              }
              let x_val = x[${x.indicesToOffset("xIndices")}];
              ${op1}
            `;
          }
          const poolingCode = `
            ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)}

            ${shaderHelper.mainStart()}
              ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}
              let indices = ${output.offsetToIndices("global_idx")};
              var xIndices = ${output.offsetToIndices("global_idx")};

              var offsets: array<u32, ${stridesRank}>;

              var value = ${dataType}(${start});
              var pad = 0;
              var isPad = false;

              for (var i: u32 = 0u; i < uniforms.kernelSize; i++) {
                var offset = i;
                for (var j = 0u; j < ${stridesRank - 1}u; j++) {
                  offsets[j] = offset / ${getElementAt("uniforms.kernelStrides", "j", stridesRank)};
                  offset -= offsets[j] * ${getElementAt("uniforms.kernelStrides", "j", stridesRank)};
                }
                offsets[${stridesRank - 1}] = offset;

                isPad = false;
                for (var j = ${rank - stridesRank}u; j < ${rank}u; j++) {
                  xIndices[j] = indices[j] * ${getElementAt(
            "uniforms.strides",
            `j - ${rank - stridesRank}u`,
            stridesRank
          )}
                    + offsets[j - ${rank - stridesRank}u] - ${getElementAt("uniforms.pads", "j - 2u", padsRank)};
                  ${padCode}
              }
              ${op2}

              output[global_idx] = value;
            }`;
          return poolingCode;
        }
      };
      createShaderKeyFromAttributes = (attributes) => `${attributes.format};${attributes.ceilMode};${attributes.autoPad};${attributes.kernelShape.length}`;
      createAveragePoolShaderKeyFromAttributes = (attributes) => `${createShaderKeyFromAttributes(attributes)};${attributes.countIncludePad}`;
      createMaxPoolShaderKeyFromAttributes = (attributes) => `${createShaderKeyFromAttributes(attributes)};${attributes.storageOrder};${attributes.dilations}`;
      parsePoolCommonAttributes = (attributes) => ({
        format: attributes.format,
        autoPad: ["NOTSET", "VALID", "SAME_UPPER", "SAME_LOWER"][attributes.auto_pad],
        ceilMode: attributes.ceil_mode,
        kernelShape: attributes.kernel_shape,
        strides: attributes.strides,
        pads: attributes.pads
      });
      createAveragePoolProgramInfo = (name, input, isGlobalOperator, attributes) => {
        const [adjustedAttributes, outputShape] = getAdjustedPoolAttributesAndOutputShape(
          input,
          attributes,
          isGlobalOperator
        );
        const x = inputVariable("x", input.dataType, input.dims.length);
        const dataType = x.type.value;
        const op1 = "value += x_val;";
        let op2 = "";
        if (adjustedAttributes.countIncludePad) {
          op2 += `value /= ${dataType}(uniforms.kernelSize);`;
        } else {
          op2 += `value /= ${dataType}(i32(uniforms.kernelSize) - pad);`;
        }
        const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] = getUniformAndPadInfo(
          outputShape,
          adjustedAttributes
        );
        programUniforms.push(...createTensorShapeVariables(input.dims, outputShape));
        const inputDependencies = ["rank"];
        return {
          name,
          shaderCache: {
            hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`,
            inputDependencies
          },
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: input.dataType }],
            dispatchGroup: { x: Math.ceil(
              ShapeUtil.size(outputShape) / 64
              /* workgroup size */
            ) },
            programUniforms
          }),
          getShaderSource: (shaderHelper) => generatePoolingCode(
            shaderHelper,
            x,
            input.dims.length,
            outputShape.length,
            adjustedAttributes,
            op1,
            op2,
            0,
            uniforms,
            hasPads,
            pwStartEndNotZero,
            phStartEndNotZero
          )
        };
      };
      parseAveragePoolAttributes = (attributes) => {
        const countIncludePad = attributes.count_include_pad === 0 ? false : true;
        const attr = parsePoolCommonAttributes(attributes);
        if (attr.ceilMode !== 0) {
          throw new Error("using ceil() in shape computation is not yet supported for AveragePool");
        }
        const averagePoolAttributes = { countIncludePad, ...attr, cacheKey: "" };
        return { ...averagePoolAttributes, cacheKey: createAveragePoolShaderKeyFromAttributes(averagePoolAttributes) };
      };
      averagePool = (context, attributes) => {
        validateInputs25(context.inputs);
        context.compute(createAveragePoolProgramInfo("AveragePool", context.inputs[0], false, attributes));
      };
      globalPoolAttributes = {
        autoPad: "",
        ceilMode: 0,
        countIncludePad: false,
        kernelShape: [],
        strides: [],
        pads: [],
        storageOrder: 0,
        dilations: []
      };
      parseGlobalAveragePoolAttributes = (attributes) => {
        const format = attributes.format;
        return { format, ...globalPoolAttributes, cacheKey: format };
      };
      globalAveragePool = (context, attributes) => {
        validateInputs25(context.inputs);
        context.compute(createAveragePoolProgramInfo("GlobalAveragePool", context.inputs[0], true, attributes));
      };
      createMaxPoolProgramInfo = (name, input, isGlobalOperator, attributes) => {
        const [adjustedAttributes, outputShape] = getAdjustedPoolAttributesAndOutputShape(
          input,
          attributes,
          isGlobalOperator
        );
        const op1 = `
      value = max(x_val, value);
    `;
        const op2 = "";
        const x = inputVariable("x", input.dataType, input.dims.length);
        const inputDependencies = ["rank"];
        const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] = getUniformAndPadInfo(
          outputShape,
          adjustedAttributes
        );
        programUniforms.push(...createTensorShapeVariables(input.dims, outputShape));
        return {
          name,
          shaderCache: {
            hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`,
            inputDependencies
          },
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: input.dataType }],
            dispatchGroup: { x: Math.ceil(
              ShapeUtil.size(outputShape) / 64
              /* workgroup size */
            ) },
            programUniforms
          }),
          getShaderSource: (shaderHelper) => generatePoolingCode(
            shaderHelper,
            x,
            input.dims.length,
            outputShape.length,
            adjustedAttributes,
            op1,
            op2,
            input.dataType === 10 /* float16 */ ? -65504 : -1e5,
            uniforms,
            hasPads,
            pwStartEndNotZero,
            phStartEndNotZero
          )
        };
      };
      maxPool = (context, attributes) => {
        validateInputs25(context.inputs);
        context.compute(createMaxPoolProgramInfo("MaxPool", context.inputs[0], false, attributes));
      };
      parseMaxPoolAttributes = (attributes) => {
        const storageOrder = attributes.storage_order;
        const dilations = attributes.dilations;
        const attr = parsePoolCommonAttributes(attributes);
        if (storageOrder !== 0) {
          throw new Error("column major storage order is not yet supported for MaxPool");
        }
        if (attr.ceilMode !== 0) {
          throw new Error("using ceil() in shape computation is not yet supported for MaxPool");
        }
        const maxPoolAttributes = { storageOrder, dilations, ...attr, cacheKey: "" };
        return { ...maxPoolAttributes, cacheKey: createMaxPoolShaderKeyFromAttributes(maxPoolAttributes) };
      };
      parseGlobalMaxPoolAttributes = (attributes) => {
        const format = attributes.format;
        return { format, ...globalPoolAttributes, cacheKey: format };
      };
      globalMaxPool = (context, attributes) => {
        validateInputs25(context.inputs);
        context.compute(createMaxPoolProgramInfo("GlobalMaxPool", context.inputs[0], true, attributes));
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/quantize-linear.ts
  var validateInputs26, createDequantizeLinearProgramInfo, dequantizeLinear, parseDequantizeLinearAttributes;
  var init_quantize_linear = __esm({
    "web/lib/wasm/jsep/webgpu/ops/quantize-linear.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      validateInputs26 = (inputs, attributes) => {
        if (inputs.length < 2 || inputs.length > 3) {
          throw new Error("DequantizeLinear requires 2 or 3 inputs.");
        }
        if (inputs.length === 3 && inputs[1].dims === inputs[2].dims) {
          throw new Error("x-scale and x-zero-point must have the same shape.");
        }
        if (inputs.length === 3 && inputs[0].dataType !== inputs[2].dataType) {
          throw new Error("x and x-zero-point must have the same data type.");
        }
        if (inputs[1].dims.length !== 0 && inputs[1].dims.length !== 1 && inputs[1].dims.length !== inputs[0].dims.length) {
          throw new Error("scale input must be a scalar, a 1D tensor, or have the same rank as the input tensor.");
        }
        if (inputs.length > 2) {
          if (inputs[0].dataType !== inputs[2].dataType) {
            throw new Error("x and x-zero-point must have the same data type.");
          }
          if (inputs[1].dims.length !== inputs[2].dims.length) {
            throw new Error("scale and zero-point inputs must have the same rank.");
          }
          if (!inputs[1].dims.map((d, i) => d === inputs[2].dims[i]).reduce((a, b) => a && b, true)) {
            throw new Error("scale and zero-point inputs must have the same shape.");
          }
        }
        if (attributes.blockSize > 0) {
          if (inputs[1].dims.length === 0 || inputs[1].dims.length === 1 && inputs[1].dims[0] === 1) {
            throw new Error("blockSize must be set only for block quantization.");
          }
          if (!inputs[1].dims.map((d, i) => i === attributes.axis || d === inputs[0].dims[i]).reduce((a, b) => a && b, true)) {
            throw new Error("For block qunatization, scale input shape to match the input shape except for the axis");
          }
          if (inputs[1].dims.length !== inputs[0].dims.length) {
            throw new Error("For block qunatization the scale input rank must be the same as the x rank.");
          }
          const dI = inputs[0].dims[attributes.axis];
          const si = inputs[1].dims[attributes.axis];
          if (attributes.blockSize < Math.ceil(dI / si) || attributes.blockSize > Math.ceil(dI / (si - 1) - 1)) {
            throw new Error("blockSize must be with in the range [ceil(dI / Si), ceil(dI / (Si - 1) - 1)].");
          }
        }
      };
      createDequantizeLinearProgramInfo = (inputs, attributes) => {
        const axis = ShapeUtil.normalizeAxis(attributes.axis, inputs[0].dims.length);
        const inputType = inputs[0].dataType;
        const isSigned = inputType === 3 /* int8 */;
        const outputShape = inputs[0].dims;
        const dataType = inputs[1].dataType;
        const outputSize = ShapeUtil.size(outputShape);
        const isPacked = inputType === 3 /* int8 */ || inputType === 2 /* uint8 */;
        const inputShape = isPacked ? [Math.ceil(ShapeUtil.size(inputs[0].dims) / 4)] : inputs[0].dims;
        const scaleShape = inputs[1].dims;
        const zeroPointInput = inputs.length > 2 ? inputs[2] : void 0;
        const zeroPointShape = zeroPointInput ? isPacked ? [Math.ceil(ShapeUtil.size(zeroPointInput.dims) / 4)] : zeroPointInput.dims : void 0;
        const perLayerQuantization = scaleShape.length === 0 || scaleShape.length === 1 && scaleShape[0] === 1;
        const perAxisQuantization = perLayerQuantization === false && scaleShape.length === 1;
        const maxComponents = getMaxComponents(outputSize);
        const useComponents = perLayerQuantization && (!isPacked || maxComponents === 4);
        const components = useComponents ? maxComponents : 1;
        const inputComponent = useComponents && !isPacked ? maxComponents : 1;
        const input = inputVariable("input", isPacked ? 12 /* uint32 */ : inputType, inputShape.length, inputComponent);
        const scale = inputVariable("scale", dataType, scaleShape.length);
        const zeroPoint = zeroPointInput ? inputVariable("zero_point", isPacked ? 12 /* uint32 */ : inputType, zeroPointShape.length) : void 0;
        const output = outputVariable("output", dataType, outputShape.length, components);
        const inputVariables = [input, scale];
        if (zeroPoint) {
          inputVariables.push(zeroPoint);
        }
        const inputShapes = [inputShape, scaleShape];
        if (zeroPointInput) {
          inputShapes.push(zeroPointShape);
        }
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize / components },
          { type: 12 /* uint32 */, data: axis },
          { type: 12 /* uint32 */, data: attributes.blockSize },
          ...createTensorShapeVariables(...inputShapes, outputShape)
        ];
        const getShaderSource = (shaderHelper) => {
          const uniforms = [
            { name: "output_size", type: "u32" },
            { name: "axis", type: "u32" },
            { name: "block_size", type: "u32" }
          ];
          return `
      ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}
      ${shaderHelper.mainStart()}
          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
          let output_indices = ${output.offsetToIndices("global_idx")};

          // Set input x
          ${(() => {
            if (isPacked) {
              return `
            let input = ${input.getByOffset("global_idx / 4")};
            let x_vec = ${isSigned ? "unpack4xI8(input)" : "unpack4xU8(input)"};
            let x_value = ${components === 1 ? "x_vec[global_idx % 4]" : "x_vec"};`;
            } else {
              return `let x_value = ${input.getByOffset("global_idx")};`;
            }
          })()};

          // Set scale input
          ${(() => {
            if (perLayerQuantization) {
              return `let scale_value= ${scale.getByOffset("0")}`;
            } else if (perAxisQuantization) {
              return `
            let scale_index = ${output.indicesGet("output_indices", "uniforms.axis")};
            let scale_value= ${scale.getByOffset("scale_index")};`;
            } else {
              return `
            var scale_indices: ${scale.type.indices} = output_indices;
            let index = ${scale.indicesGet("scale_indices", "uniforms.axis")} / uniforms.block_size;
            ${scale.indicesSet("scale_indices", "uniforms.axis", "index")};
            let scale_value= ${scale.getByIndices("scale_indices")};`;
            }
          })()};

          // Set zero-point input
          ${(() => {
            if (zeroPoint) {
              if (perLayerQuantization) {
                if (isPacked) {
                  return `
                let zero_point_input = ${zeroPoint.getByOffset("0")};
                let zero_point_vec =  ${isSigned ? "unpack4xI8(zero_point_input)" : "unpack4xU8(zero_point_input)"};
                let zero_point_value= zero_point_vec[0]`;
                } else {
                  return `let zero_point_value = ${zeroPoint.getByOffset("0")}`;
                }
              } else if (perAxisQuantization) {
                if (isPacked) {
                  return `
                let zero_point_index = ${output.indicesGet("output_indices", "uniforms.axis")};
                let zero_point_input = ${zeroPoint.getByOffset("zero_point_index / 4")};
                let zero_point_vec =  ${isSigned ? "unpack4xI8(zero_point_input)" : "unpack4xU8(zero_point_input)"};
                let zero_point_value = zero_point_vec[zero_point_index % 4]`;
                } else {
                  return `
                let zero_point_index = ${output.indicesGet("output_indices", "uniforms.axis")};
                let zero_point_value = ${zeroPoint.getByOffset("zero_point_index")};`;
                }
              } else {
                if (isPacked) {
                  return `
                let zero_point_offset = ${scale.indicesToOffset("scale_indices")};
                let zero_point_input = ${zeroPoint.getByOffset("zero_point_offset / 4")};
                let zero_point_vec = ${isSigned ? "unpack4xI8(zero_point_input)" : "unpack4xU8(zero_point_input)"};
                let zero_point_value = zero_point_vec[zero_point_offset % 4];`;
                } else {
                  return `let zero_point_value = ${zeroPoint.getByIndices("scale_indices")};`;
                }
              }
            } else {
              return `let zero_point_value = ${isPacked ? isSigned ? "i32" : "u32" : input.type.value}(0);`;
            }
          })()};
      // Compute and write output
      ${output.setByOffset("global_idx", `${output.type.value}(x_value - zero_point_value) * scale_value`)};
      }`;
        };
        return {
          name: "DequantizeLinear",
          shaderCache: {
            hint: attributes.cacheKey,
            inputDependencies: zeroPoint ? ["rank", "rank", "rank"] : ["rank", "rank"]
          },
          getShaderSource,
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType }],
            dispatchGroup: { x: Math.ceil(outputSize / components / 64), y: 1, z: 1 },
            programUniforms
          })
        };
      };
      dequantizeLinear = (context, attributes) => {
        validateInputs26(context.inputs, attributes);
        context.compute(createDequantizeLinearProgramInfo(context.inputs, attributes));
      };
      parseDequantizeLinearAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis, blockSize: attributes.blockSize });
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/range.ts
  var validateInputsContent, createRangeProgramInfo, range;
  var init_range = __esm({
    "web/lib/wasm/jsep/webgpu/ops/range.ts"() {
      "use strict";
      init_esm();
      init_wasm_common();
      init_common();
      validateInputsContent = (start, limit, delta) => {
        const sameStartLimit = start === limit;
        const increasingRangeNegativeStep = start < limit && delta < 0;
        const decreasingRangePositiveStep = start > limit && delta > 0;
        if (sameStartLimit || increasingRangeNegativeStep || decreasingRangePositiveStep) {
          throw new Error("Range these inputs' contents are invalid.");
        }
      };
      createRangeProgramInfo = (start, limit, delta, dataType) => {
        const numElements = Math.abs(Math.ceil((limit - start) / delta));
        const outputShape = [numElements];
        const outputSize = numElements;
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: dataType, data: start },
          { type: dataType, data: delta },
          ...createTensorShapeVariables(outputShape)
        ];
        const getShaderSource = (shaderHelper) => {
          const output = outputVariable("output", dataType, outputShape.length);
          const wgslType = output.type.value;
          const uniforms = [
            { name: "outputSize", type: "u32" },
            { name: "start", type: wgslType },
            { name: "delta", type: wgslType }
          ];
          return `
        ${shaderHelper.registerUniforms(uniforms).declareVariables(output)}
        ${shaderHelper.mainStart()}
        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}
        output[global_idx] = uniforms.start + ${wgslType}(global_idx) * uniforms.delta;
      }`;
        };
        return {
          name: "Range",
          shaderCache: { hint: `${dataType}` },
          getShaderSource,
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms
          })
        };
      };
      range = (context) => {
        let start = 0;
        let limit = 0;
        let delta = 0;
        if (context.inputs[0].dataType === 6 /* int32 */) {
          start = context.inputs[0].getInt32Array()[0];
          limit = context.inputs[1].getInt32Array()[0];
          delta = context.inputs[2].getInt32Array()[0];
        } else if (context.inputs[0].dataType === 1 /* float */) {
          start = context.inputs[0].getFloat32Array()[0];
          limit = context.inputs[1].getFloat32Array()[0];
          delta = context.inputs[2].getFloat32Array()[0];
        }
        if (env2.webgpu.validateInputContent) {
          validateInputsContent(start, limit, delta);
        }
        context.compute(createRangeProgramInfo(start, limit, delta, context.inputs[0].dataType), { inputs: [] });
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/scatter-nd.ts
  var atomicReductionSnippet, createScatterNDProgramInfo, parseScatterNDAttributes, scatterND;
  var init_scatter_nd = __esm({
    "web/lib/wasm/jsep/webgpu/ops/scatter-nd.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      atomicReductionSnippet = (reduction, ptr, v, type) => {
        if (reduction !== "none" && type !== "i32" && type !== "u32" && type !== "f32") {
          throw new Error(`Input ${type} is not supported with reduction ${reduction}.`);
        }
        const floatStart = `{
                var oldValue = 0;
                loop {
                  let newValueF32 =`;
        const floatEnd = `;
                  let newValue = bitcast<i32>(newValueF32);
                  let res = atomicCompareExchangeWeak(&${ptr}, oldValue, newValue);
                  if res.exchanged {
                    break;
                  }
                  oldValue = res.old_value;
                }
              }`;
        switch (reduction) {
          case "none":
            return `${ptr}=${v};`;
          case "add":
            if (type === "i32" || type === "u32") {
              return `atomicAdd(&${ptr}, bitcast<${type}>(${v}));`;
            } else {
              return `
              ${floatStart}bitcast<${type}>(oldValue) + (${v})${floatEnd}`;
            }
          case "max":
            if (type === "i32" || type === "u32") {
              return `atomicMax(&${ptr}, bitcast<${type}>(${v}));`;
            } else {
              return `
                ${floatStart}max(bitcast<f32>(oldValue), (${v}))${floatEnd}`;
            }
          case "min":
            if (type === "i32" || type === "u32") {
              return `atomicMin(&${ptr}, bitcast<${type}>(${v}));`;
            } else {
              return `${floatStart}min(bitcast<${type}>(oldValue), (${v}))${floatEnd}`;
            }
          case "mul":
            return `${floatStart}(bitcast<${type}>(oldValue) * (${v}))${floatEnd}`;
          default:
            throw new Error(`Reduction ${reduction} is not supported.`);
        }
      };
      createScatterNDProgramInfo = (inputs, attributes) => {
        const inputShape = inputs[0].dims;
        const indicesShape = inputs[1].dims;
        const outputShape = inputShape;
        const components = 1;
        const outputSize = Math.ceil(ShapeUtil.sizeToDimension(indicesShape, indicesShape.length - 1) / components);
        const lastIndexDimension = indicesShape[indicesShape.length - 1];
        const numUpdatesElements = ShapeUtil.sizeFromDimension(inputShape, lastIndexDimension);
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 12 /* uint32 */, data: lastIndexDimension },
          { type: 12 /* uint32 */, data: numUpdatesElements },
          ...createTensorShapeVariables(inputs[1].dims, inputs[2].dims, outputShape)
        ];
        const getShaderSource = (shaderHelper) => {
          const indices = inputVariable("indices", inputs[1].dataType, inputs[1].dims.length);
          const updates = inputVariable("updates", inputs[2].dataType, inputs[2].dims.length, components);
          const output = attributes.reduction !== "none" && attributes.reduction !== "" ? atomicOutputVariable("output", inputs[0].dataType, outputShape.length) : outputVariable("output", inputs[0].dataType, outputShape.length, components);
          return `
      ${shaderHelper.registerUniform("output_size", "u32").registerUniform("last_index_dimension", "u32").registerUniform("num_updates_elements", "u32").declareVariables(indices, updates, output)}
      ${shaderHelper.mainStart()}
        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
  var data_offset = 0u;
  let indices_start = uniforms.last_index_dimension * global_idx;
  let indices_end = indices_start + uniforms.last_index_dimension;
  for (var i = indices_start; i < indices_end; i++) {
    var index = i32(indices[i].x);
    ${inputs[0].dims.length === 1 ? `
    let element_count_dim = uniforms.output_strides;
    let dim_value = uniforms.output_shape;` : `
    let element_count_dim = uniforms.output_strides[i - indices_start];
    let dim_value = uniforms.output_shape[i - indices_start];`}
    if (index >= 0) {
      if (index >= i32(dim_value)) {
        index = i32(dim_value - 1);
      }
    } else {
      if (index < -i32(dim_value)) {
        index = 0;
      } else {
        index += i32(dim_value);
      }
    }
    data_offset += u32((u32(index) * element_count_dim));
  }

  for (var i = 0u; i < uniforms.num_updates_elements; i++) {
    let value = updates[uniforms.num_updates_elements * global_idx + i];
    ${atomicReductionSnippet(
            attributes.reduction,
            "output[data_offset + i]",
            "value",
            output.type.value
          )}
  }

      }`;
        };
        return {
          name: "ScatterND",
          shaderCache: {
            hint: `${attributes.cacheKey}_${attributes.reduction}`,
            inputDependencies: ["rank", "rank"]
          },
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms
          }),
          getShaderSource
        };
      };
      parseScatterNDAttributes = (attributes) => createAttributeWithCacheKey({ reduction: attributes.reduction });
      scatterND = (context, attributes) => {
        context.compute(createScatterNDProgramInfo(context.inputs, attributes), {
          inputs: [context.inputs[1], context.inputs[2]],
          outputs: []
        });
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/resize.ts
  var validateScales, updateScales, validateInputs27, getSafeIntegerDivision, getOriginalCoordinateFromResizedCoordinate, getNearestPixelFromOriginal, updateRoI, initOutputShape, adjustOutputShape, calculateOriginalIndicesFromOutputIndices, calculateInputIndicesFromOutputIndices, checkInputIndices, setChannelAndBatchIndices, bilinearInterpolation, bicubicInterpolation, trilinearInterpolation, createResizeProgramInfo, getOpsetVersionFromCustomDataBuffer, resize, parseResizeAttributes;
  var init_resize = __esm({
    "web/lib/wasm/jsep/webgpu/ops/resize.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      validateScales = (scales, attributes) => {
        scales.every(
          (value) => value > 0 || (() => {
            throw new Error("Resize requires scales input values to be positive");
          })
        );
        if (scales.length > 0) {
          if (attributes.mode === "linear") {
            if (!(scales.length === 2 || scales.length === 3 || scales.length === 4 && scales[0] === 1 && scales[1] === 1 || scales.length === 4 && scales[0] === 1 && scales[3] === 1 || scales.length === 5 && scales[0] === 1 && scales[1] === 1)) {
              throw new Error(
                `For linear mode, Resize requires scales to be 2D, 3D, 4D with either two outermost or one innermost and
            one outermost scale values equal to 1, or 5D with two outermost scale values equal to 1`
              );
            }
          } else if (attributes.mode === "cubic") {
            if (!(scales.length === 2 || scales.length === 4 && scales[0] === 1 && scales[1] === 1 || scales.length === 4 && scales[0] === 1 && scales[3] === 1)) {
              throw new Error("Resize requires scales input size to be 2 or 4 for cubic mode");
            }
          }
        }
      };
      updateScales = (scales, axes, rank) => {
        axes.every(
          (value) => value >= 0 && value < rank || (() => {
            throw new Error("Resize requires axes input values to be positive and less than rank");
          })
        );
        const newScales = new Array(rank).fill(1);
        axes.forEach((value, index) => newScales[value] = scales[index]);
        return newScales;
      };
      validateInputs27 = (inputs, attributes, opsetVersion, scales, sizes, roi) => {
        const [roiInputIndex, scalesInputIndex, sizesInputIndex] = opsetVersion > 10 ? [1, 2, 3] : [-1, inputs.length > 1 ? 1 : -1, -1];
        const rank = inputs[0].dims.length;
        if (roiInputIndex > 0 && inputs.length > roiInputIndex && inputs[roiInputIndex].dims.length > 0) {
          inputs[roiInputIndex].getFloat32Array().forEach((value) => roi.push(value));
        } else if (attributes.coordinateTransformMode === "tf_crop_and_resize") {
          throw new Error("Resize requires RoI input to be specified when coordinateTransformMode is tfCropAndResize");
        }
        if (scalesInputIndex > 0 && inputs.length > scalesInputIndex && inputs[scalesInputIndex].dims.length === 1 && inputs[scalesInputIndex].dims[0] > 0) {
          inputs[scalesInputIndex].getFloat32Array().forEach((value) => scales.push(value));
          if (scales.length !== 0 && scales.length !== rank && opsetVersion >= 18 && scales.length !== attributes.axes.length) {
            throw new Error("Resize requires scales input size to be same as input rank or axes size for opset 18 and up");
          }
          validateScales(scales, attributes);
          if (attributes.axes.length > 0) {
            updateScales(scales, attributes.axes, rank).forEach((value, index) => scales[index] = value);
          }
        }
        if (sizesInputIndex > 0 && inputs.length > sizesInputIndex && inputs[sizesInputIndex].dims.length === 1 && inputs[sizesInputIndex].dims[0] > 0) {
          inputs[sizesInputIndex].getBigInt64Array().forEach((value) => sizes.push(Number(value)));
          if (sizes.length !== 0 && sizes.length !== rank && opsetVersion >= 18 && sizes.length !== attributes.axes.length) {
            throw new Error("Resize requires sizes input size to be same as input rank or axes size for opset 18 and up");
          }
        }
        if (attributes.axes.length > 0) {
          if (scales.length !== 0 && scales.length !== attributes.axes.length) {
            throw new Error('Resize requires "scales" input size to be of axes rank when axes attributes is specified');
          }
          if (sizes.length !== 0 && sizes.length !== attributes.axes.length) {
            throw new Error('Resize requires "sizes" input size to be of rank axes rank when axes attributes is specified');
          }
        }
        if (typeof scales !== "undefined" && typeof sizes !== "undefined" && scales.length > 0 && sizes.length > rank) {
          throw new Error("Resize requires only of scales or sizes to be specified");
        }
      };
      getSafeIntegerDivision = (a, b, c, dType) => `
  // The whole part and the fractional part are calculated separately due to inaccuracy of floating
  // point division. As an example, f32(21) / f32(7) may evaluate to 2.99... instead of 3, causing an
  // offset-by-one error later in floor().
  let big = (${a}) * (${b});
  let whole = ${dType}(big / (${c}));
  let fract = ${dType}(big % (${c})) / ${dType}(${c});
  return whole + fract;
`;
      getOriginalCoordinateFromResizedCoordinate = (coordinateTransferMode, dType) => `fn getOriginalCoordinateFromResizedCoordinate(xResized: u32, xScale: f32, lengthResized: u32,
     lengthOriginal: u32, roiStart: f32, roiEnd: f32) -> ${dType} { ` + (() => {
        switch (coordinateTransferMode) {
          case "asymmetric":
            return `
          if (xScale < 1.0 || floor(xScale) != xScale) {
            return ${dType}(xResized) / ${dType}(xScale);
          } else {
            ${getSafeIntegerDivision("xResized", "lengthOriginal", "lengthResized", dType)}
          }
        `;
          case "pytorch_half_pixel":
            return `if (lengthResized > 1) {
                    return (${dType}(xResized) + 0.5) / ${dType}(xScale) - 0.5;
                  } else {
                    return 0.0;
                  }`;
          case "tf_half_pixel_for_nn":
            return `return (${dType}(xResized) + 0.5) / ${dType}(xScale);`;
          case "align_corners":
            return `if (lengthResized == 1) {
                    return 0.0;
                  } else {
                    ${getSafeIntegerDivision("xResized", "lengthOriginal - 1", "lengthResized - 1", dType)}
                  }`;
          case "tf_crop_and_resize":
            return `if (lengthResized > 1) {
                    return ${dType}(roiStart) * ${dType}(lengthOriginal - 1) +
                        (${dType}(xResized) * ${dType}(roiEnd - roiStart) * ${dType}(lengthOriginal - 1)) /
                        ${dType}(lengthResized - 1);
                  } else {
                    return 0.5 * ${dType}(roiStart + roiEnd) * ${dType}(lengthOriginal - 1);
                  }`;
          case "half_pixel_symmetric":
            return `const outputWidth = ${dType}xScale * ${dType}(lengthResized);
                  const adjustment = ${dType}(lengthResized) / outputWidth;
                  const center = ${dType}(lengthOriginal) / 2;
                  const offset = center * (1 - adjustment);
                  return offset + ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`;
          case "half_pixel":
            return `return ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`;
          default:
            throw new Error(`Coordinate transform mode ${coordinateTransferMode} is not supported`);
        }
      })() + "}";
      getNearestPixelFromOriginal = (nearestMode, opsetVersion, dType) => `fn getNearestPixelFromOriginal(xOriginal: ${dType}, isDownSample: bool) -> ${dType} {` + (() => {
        switch (nearestMode) {
          case "round_prefer_ceil":
            return "if (fract(xOriginal) == 0.5) {             return ceil(xOriginal);           } else {             return round(xOriginal);           }";
          case "floor":
            return "return floor(xOriginal);";
          case "ceil":
            return "return ceil(xOriginal);";
          case "round_prefer_floor":
            return "if (fract(xOriginal) == 0.5) {                     return floor(xOriginal);                   } else {                     return round(xOriginal);                   }";
          case "simple":
          default:
            if (opsetVersion < 11) {
              return "if (isDownSample)                     {                       return ceil(xOriginal);                     } else {                       return xOriginal;                     }";
            }
            throw new Error(`Nearest mode ${nearestMode} is not supported`);
        }
      })() + "}";
      updateRoI = (roi, axes, rank) => {
        const roiTmp = new Array(rank).fill(0).concat(new Array(rank).fill(1));
        const roiLocal = roi.length === 0 ? roiTmp : roi.slice();
        if (axes.length > 0) {
          axes.forEach((v, i) => {
            roiTmp[v] = roiLocal[i];
            roiTmp[i + rank] = roiLocal[axes.length + i];
          });
          return roiTmp;
        }
        return roiLocal;
      };
      initOutputShape = (inputShape, scales, sizes, axes) => {
        let outputShape = [];
        if (sizes.length > 0) {
          if (axes.length > 0) {
            inputShape.forEach((v) => outputShape.push(v));
            if (Math.max(...axes) > inputShape.length) {
              throw new Error("axes is out of bound");
            }
            axes.forEach((v, i) => outputShape[v] = sizes[i]);
          } else {
            sizes.forEach((v) => outputShape.push(v));
          }
        } else {
          if (scales.length === 0) {
            throw new Error("Resize requires either scales or sizes.");
          } else {
            outputShape = inputShape.map((value, index) => Math.round(value * scales[index]));
          }
        }
        return outputShape;
      };
      adjustOutputShape = (inputShape, scales, attributes) => {
        const scaleInPolicy = (() => {
          switch (attributes.keepAspectRatioPolicy) {
            case "not_larger":
              return attributes.axes.length > 0 ? Math.min(...attributes.axes.map((i) => scales[i]), Number.MAX_VALUE) : Math.min(...scales, Number.MAX_VALUE);
            case "not_smaller":
              return attributes.axes.length > 0 ? Math.max(...attributes.axes.map((i) => scales[i]), Number.MIN_VALUE) : Math.max(...scales, Number.MIN_VALUE);
            default:
              throw new Error(`Keep aspect ratio policy ${attributes.keepAspectRatioPolicy} is not supported`);
          }
        })();
        scales.fill(1, 0, scales.length);
        const adjustedOutputShape = inputShape.slice();
        if (attributes.axes.length > 0) {
          attributes.axes.forEach((v) => scales[v] = scaleInPolicy);
          attributes.axes.forEach((v) => adjustedOutputShape[v] = Math.round(inputShape[v] * scales[v]));
        } else {
          scales.fill(scaleInPolicy, 0, scales.length);
          adjustedOutputShape.forEach((v, i) => adjustedOutputShape[i] = Math.round(v * scales[i]));
        }
        return adjustedOutputShape;
      };
      calculateOriginalIndicesFromOutputIndices = (output, inputShape, outputShape, scalesLength, roiLength) => `
    fn calculateOriginalIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> array<${output.type.value}, ${outputShape.length}> {
      var original_indices: array<${output.type.value}, ${outputShape.length}>;
      for (var i:u32 = 0; i < ${outputShape.length}; i++) {
        var output_index = ${output.indicesGet("output_indices", "i")};
        var scale = ${getElementAt("uniforms.scales", "i", scalesLength)};
        var roi_low = ${getElementAt("uniforms.roi", "i", roiLength)};
        var roi_hi = ${getElementAt("uniforms.roi", `i + ${inputShape.length}`, roiLength)};
        if (scale == 1.0) {
          original_indices[i] = ${output.type.value}(output_index);
        } else {
          var input_shape_i = ${getElementAt("uniforms.input_shape", "i", inputShape.length)};
          var output_shape_i = ${getElementAt("uniforms.output_shape", "i", outputShape.length)};
          original_indices[i] = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,
                                                                           input_shape_i, roi_low, roi_hi);
        }
      }
      return original_indices;
    }`;
      calculateInputIndicesFromOutputIndices = (input, output, inputShape, outputShape, scalesLength, roiLength, useExtrapolation) => `
    fn calculateInputIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} {
      var input_indices: ${input.type.indices};
      for (var i:u32 = 0; i < ${outputShape.length}; i++) {
        var output_index = ${output.indicesGet("output_indices", "i")};
        var input_index: u32;
        var scale = ${getElementAt("uniforms.scales", "i", scalesLength)};
        if (scale == 1.0) {
          input_index = output_index;
        } else {
          var roi_low = ${getElementAt("uniforms.roi", "i", roiLength)};
          var roi_hi = ${getElementAt("uniforms.roi", `i + ${inputShape.length}`, roiLength)};
          var input_shape_i = ${getElementAt("uniforms.input_shape", "i", inputShape.length)};
          var output_shape_i = ${getElementAt("uniforms.output_shape", "i", outputShape.length)};
          var original_idx = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,
                                                                        input_shape_i, roi_low, roi_hi);
          if (!${useExtrapolation} || (original_idx >= 0 && original_idx < ${output.type.value}(input_shape_i))) {
            if (original_idx < 0) {
              input_index = 0;
            } else if (original_idx > ${output.type.value}(input_shape_i - 1)) {
              input_index = input_shape_i - 1;
            } else {
              input_index = u32(getNearestPixelFromOriginal(original_idx, scale < 1));
            }
          } else {
            input_index = u32(original_idx);
          }
        }
        ${input.indicesSet("input_indices", "i", "input_index")}
      }
      return input_indices;
    }`;
      checkInputIndices = (input, inputShape) => `
    fn checkInputIndices(input_indices: ${input.type.indices}) -> bool {
      for (var i:u32 = 0; i < ${inputShape.length}; i++) {
        var input_index = ${input.indicesGet("input_indices", "i")};
        if (input_index < 0 || input_index >= ${getElementAt("uniforms.input_shape", "i", inputShape.length)}) {
          return false;
        }
      }
      return true;
    }`;
      setChannelAndBatchIndices = (input, channelIdx, batchIdx, spacialDims) => input.rank > spacialDims ? `
    ${input.indicesSet("input_indices", channelIdx, "channel")};
    ${input.indicesSet("input_indices", batchIdx, "batch")};
` : "";
      bilinearInterpolation = (input, output, inputShape, useExtrapolation, extrapolationValue) => {
        const isNchw = true;
        const [batchIdx, heightIdx, widthIdx, channelIdx] = inputShape.length === 2 ? [-1, 0, 1, -1] : isNchw ? [0, 2, 3, 1] : [0, 1, 2, 3];
        const dType = input.type.value;
        return `
    fn getInputValue(batch: u32, channel: u32, row: u32, col: u32) -> ${dType} {
      var input_indices: ${input.type.indices};
      ${input.indicesSet("input_indices", heightIdx, `max(0, min(row, ${inputShape[heightIdx]} - 1))`)};
      ${input.indicesSet("input_indices", widthIdx, `max(0, min(col, ${inputShape[widthIdx]} - 1))`)};
      ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 2)}
      return ${input.getByIndices("input_indices")};
    }

    fn bilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} {
      var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);
      var row:${dType} = originalIndices[${heightIdx}];
      var col:${dType} = originalIndices[${widthIdx}];
      ${useExtrapolation ? `if (row < 0 || row > (${inputShape[heightIdx]} - 1) || col < 0 || col > (${inputShape[widthIdx]} - 1)) {
        return ${extrapolationValue};
      }` : ""};
      row = max(0, min(row, ${inputShape[heightIdx]} - 1));
      col = max(0, min(col, ${inputShape[widthIdx]} - 1));
      var row1: u32 = u32(row);
      var col1: u32 = u32(col);
      var row2: u32 = u32(row + 1);
      var col2: u32 = u32(col + 1);
      var channel: u32 = ${inputShape.length > 2 ? `u32(originalIndices[${channelIdx}])` : "0"};
      var batch: u32 =  ${inputShape.length > 2 ? `u32(originalIndices[${batchIdx}])` : "0"};
      var x11: ${dType} = getInputValue(batch, channel, row1, col1);
      var x12: ${dType} = getInputValue(batch, channel, row1, col2);
      var x21: ${dType} = getInputValue(batch, channel, row2, col1);
      var x22: ${dType} = getInputValue(batch, channel, row2, col2);
      var dx1: ${dType} = abs(row - ${dType}(row1));
      var dx2: ${dType} = abs(${dType}(row2) - row);
      var dy1: ${dType} = abs(col - ${dType}(col1));
      var dy2: ${dType} = abs(${dType}(col2) - col);
      if (row1 == row2) {
        dx1 = 0.5;
        dx2 = 0.5;
      }
      if (col1 == col2) {
        dy1 = 0.5;
        dy2 = 0.5;
      }
      return (x11 * dx2 * dy2 + x12 * dx2 * dy1 + x21 * dx1 * dy2 + x22 * dx1 * dy1);
    }`;
      };
      bicubicInterpolation = (input, output, inputShape, outputShape, scales, roi, cubicCoeffA, useExtrapolation, extrapolationValue, excludeOutside) => {
        const is2D = inputShape.length === 2;
        const isNchw = true;
        const [heightIdx, widthIdx] = is2D ? [0, 1] : isNchw ? [2, 3] : [1, 2];
        const dType = input.type.value;
        const createCubicInterpolationFunction = (idx) => {
          const direction = idx === heightIdx ? "row" : "col";
          return `
      fn ${direction}CubicInterpolation(input_indices: ${input.type.indices}, output_indices: ${output.type.indices}) -> ${dType} {
        var output_index = ${output.indicesGet("output_indices", idx)};
        var originalIdx: ${dType} = getOriginalCoordinateFromResizedCoordinate(output_index, ${scales[idx]},
        ${outputShape[idx]}, ${inputShape[idx]}, ${roi[idx]}, ${roi[idx]} + ${inputShape.length});
        var fractOriginalIdx: ${dType} = originalIdx - floor(originalIdx);
        var coefs = getCubicInterpolationCoefs(fractOriginalIdx);

        if (${useExtrapolation} && (originalIdx < 0 || originalIdx > (${inputShape[idx]} - 1))) {
          return ${extrapolationValue};
        }
        var data: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0);
        for (var i: i32 = -1; i < 3; i++) {
          var ${direction}: ${dType} = originalIdx + ${dType}(i);
          if (${direction} < 0 || ${direction} >= ${inputShape[idx]}) {
            ${(() => {
            if (excludeOutside) {
              return `coefs[i + 1] = 0.0;
                        continue;`;
            } else if (useExtrapolation) {
              return `return ${extrapolationValue};`;
            } else {
              return `${direction} = max(0, min(${direction}, ${inputShape[idx]} - 1));`;
            }
          })()};
          }
        var input_indices_copy: ${input.type.indices} = input_indices;
          ${input.indicesSet("input_indices_copy", idx, `u32(${direction})`)};
          data[i + 1] = ${idx === heightIdx ? input.getByIndices("input_indices_copy") : "rowCubicInterpolation(input_indices_copy, output_indices)"};
        }
        return cubicInterpolation1D(data, coefs);
      }`;
        };
        return `
    ${createCubicInterpolationFunction(heightIdx)};
    ${createCubicInterpolationFunction(widthIdx)};
  fn getCubicInterpolationCoefs(s: ${dType}) -> array<${dType}, 4> {
    var absS = abs(s);
    var coeffs: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0);
    var oneMinusAbsS: ${dType} = 1.0 - absS;
    var twoMinusAbsS: ${dType} = 2.0 - absS;
    var onePlusAbsS: ${dType} = 1.0 + absS;
    coeffs[0] = ((${cubicCoeffA} * onePlusAbsS - 5 * ${cubicCoeffA}) * onePlusAbsS + 8 * ${cubicCoeffA}) * onePlusAbsS - 4 * ${cubicCoeffA};
    coeffs[1] = ((${cubicCoeffA} + 2) * absS - (${cubicCoeffA} + 3)) * absS * absS + 1;
    coeffs[2] = ((${cubicCoeffA} + 2) * oneMinusAbsS - (${cubicCoeffA} + 3)) * oneMinusAbsS * oneMinusAbsS + 1;
    coeffs[3] = ((${cubicCoeffA} * twoMinusAbsS - 5 * ${cubicCoeffA}) * twoMinusAbsS + 8 * ${cubicCoeffA}) * twoMinusAbsS - 4 * ${cubicCoeffA};
    return coeffs;
  }

  fn cubicInterpolation1D(x: array<${dType}, 4>, coefs: array<${dType}, 4>) -> ${dType} {
    var coefsSum: ${dType} = coefs[0] + coefs[1] + coefs[2] + coefs[3];
    return (x[0] * coefs[0] + x[1] * coefs[1]+ x[2] * coefs[2]+ x[3] * coefs[3]) / coefsSum;
  }

  fn bicubicInterpolation(output_indices: ${output.type.indices}) -> ${dType} {
    var input_indices: ${input.type.indices} = output_indices;
    return colCubicInterpolation(input_indices, output_indices);
  }
    `;
      };
      trilinearInterpolation = (input, output, inputShape, useExtrapolation, extrapolationValue) => {
        const isNchw = true;
        const [batchIdx, depthIdx, heightIdx, widthIdx, channelIdx] = inputShape.length === 3 ? [-1, 0, 1, 2, -1] : isNchw ? [0, 2, 3, 4, 1] : [0, 1, 2, 3, 4];
        const dType = input.type.value;
        return `
    fn getInputValue(batch: u32, channel: u32, depth:u32, height: u32, width: u32) -> ${dType} {
      var input_indices: ${input.type.indices};
      ${input.indicesSet("input_indices", depthIdx, `max(0, min(depth, ${inputShape[depthIdx]} - 1))`)};
      ${input.indicesSet("input_indices", heightIdx, `max(0, min(height, ${inputShape[heightIdx]} - 1))`)};
      ${input.indicesSet("input_indices", widthIdx, `max(0, min(width, ${inputShape[widthIdx]} - 1))`)};
      ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 3)}
      return ${input.getByIndices("input_indices")};
    }

    fn trilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} {
      var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);
      var depth:${dType} = originalIndices[${depthIdx}];
      var height:${dType} = originalIndices[${heightIdx}];
      var width:${dType} = originalIndices[${widthIdx}];
      ${useExtrapolation ? `if (depth < 0 || depth > (${inputShape[depthIdx]} - 1) || height < 0 || height > (${inputShape[heightIdx]} - 1) || width < 0 || (width > ${inputShape[widthIdx]} - 1)) {
      return ${extrapolationValue};
        }` : ""};

    depth = max(0, min(depth, ${inputShape[depthIdx]} - 1));
      height = max(0, min(height, ${inputShape[heightIdx]} - 1));
      width = max(0, min(width, ${inputShape[widthIdx]} - 1));
      var depth1: u32 = u32(depth);
      var height1: u32 = u32(height);
      var width1: u32 = u32(width);
      var depth2: u32 = u32(depth + 1);
      var height2: u32 = u32(height + 1);
      var width2: u32 = u32(width + 1);
      var channel: u32 = ${inputShape.length > 3 ? `u32(originalIndices[${channelIdx}])` : "0"};
      var batch: u32 =  ${inputShape.length > 3 ? `u32(originalIndices[${batchIdx}])` : "0"};

      var x111: ${dType} = getInputValue(batch, channel, depth1, height1, width1);
      var x112: ${dType} = getInputValue(batch, channel, depth1, height1, width2);
      var x121: ${dType} = getInputValue(batch, channel, depth1, height2, width1);
      var x122: ${dType} = getInputValue(batch, channel, depth1, height2, width2);
      var x211: ${dType} = getInputValue(batch, channel, depth2, height1, width1);
      var x212: ${dType} = getInputValue(batch, channel, depth2, height1, width2);
      var x221: ${dType} = getInputValue(batch, channel, depth2, height2, width1);
      var x222: ${dType} = getInputValue(batch, channel, depth2, height2, width2);
      var dx1: ${dType} = abs(depth - ${dType}(depth1));
      var dx2: ${dType} = abs(${dType}(depth2) - depth);
      var dy1: ${dType} = abs(height - ${dType}(height1));
      var dy2: ${dType} = abs(${dType}(height2) - height);
      var dz1: ${dType} = abs(width - ${dType}(width1));
      var dz2: ${dType} = abs(${dType}(width2) - width);
      if (depth1 == depth2) {
        dx1 = 0.5;
        dx2 = 0.5;
      }
      if (height1 == height2) {
        dy1 = 0.5;
        dy2 = 0.5;
      }
      if (width1 == width2) {
        dz1 = 0.5;
        dz2 = 0.5;
      }
      return (x111 * dx2 * dy2 * dz2 + x112 * dx2 * dy2 * dz1 + x121 * dx2 * dy1 *dz2 + x122 * dx2 * dy1 * dz1 +
              x211 * dx1 * dy2 * dz2 + x212 * dx1 * dy2 * dz1 + x221 * dx1 * dy1 *dz2 + x222 * dx1 * dy1 * dz1);
    }`;
      };
      createResizeProgramInfo = (inputTensor, attributes, opsetVersion, scalesInput, sizes, roiInput) => {
        const inputShape = inputTensor.dims;
        const roi = updateRoI(roiInput, attributes.axes, inputShape.length);
        let outputShape = initOutputShape(inputShape, scalesInput, sizes, attributes.axes);
        let scales = scalesInput.slice();
        if (scalesInput.length === 0) {
          scales = inputShape.map((value, index) => value === 0 ? 1 : outputShape[index] / value);
          if (attributes.keepAspectRatioPolicy !== "stretch") {
            outputShape = adjustOutputShape(inputShape, scales, attributes);
          }
        }
        const output = outputVariable("output", inputTensor.dataType, outputShape.length);
        const input = inputVariable("input", inputTensor.dataType, inputShape.length);
        const outputSize = ShapeUtil.size(outputShape);
        const noScale = inputShape.length === outputShape.length && inputShape.every((d, i) => d === outputShape[i]);
        const useExtrapolation = attributes.coordinateTransformMode === "tf_crop_and_resize";
        const extrapolationValue = attributes.extrapolationValue;
        const dataType = input.type.value;
        const getShaderSource = (shaderHelper) => `
      ${noScale ? "" : `
      ${getOriginalCoordinateFromResizedCoordinate(attributes.coordinateTransformMode, dataType)};
      ${(() => {
          switch (attributes.mode) {
            case "nearest":
              return `
              ${checkInputIndices(input, inputShape)};
              ${getNearestPixelFromOriginal(attributes.nearestMode, opsetVersion, dataType)};
              ${calculateInputIndicesFromOutputIndices(
                input,
                output,
                inputShape,
                outputShape,
                scales.length,
                roi.length,
                useExtrapolation
              )};
              `;
            case "linear":
              return `
              ${calculateOriginalIndicesFromOutputIndices(output, inputShape, outputShape, scales.length, roi.length)};
              ${(() => {
                if (inputShape.length === 2 || inputShape.length === 4) {
                  return `${bilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`;
                } else if (inputShape.length === 3 || inputShape.length === 5) {
                  return `${trilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`;
                } else {
                  throw Error("Linear mode only supports input dims 2, 3, 4 and 5 are supported in linear mode.");
                }
              })()};
            `;
            case "cubic":
              return `
            ${(() => {
                if (inputShape.length === 2 || inputShape.length === 4) {
                  return `${bicubicInterpolation(
                    input,
                    output,
                    inputShape,
                    outputShape,
                    scales,
                    roi,
                    attributes.cubicCoeffA,
                    useExtrapolation,
                    attributes.extrapolationValue,
                    attributes.excludeOutside
                  )}`;
                } else {
                  throw Error("Cubic mode only supports input dims 2 and 4 are supported in linear mode.");
                }
              })()};
            `;
            default:
              throw Error("Invalid resize mode");
          }
        })()};
      `}
      ${shaderHelper.registerUniform("output_size", "u32").registerUniform("scales", "f32", scales.length).registerUniform("roi", "f32", roi.length).declareVariables(input, output)}
      ${shaderHelper.mainStart()}
        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
        ${noScale ? "output[global_idx] = input[global_idx];" : `
        let output_indices = ${output.offsetToIndices("global_idx")};
        var input_indices: ${input.type.indices};
        ${(() => {
          switch (attributes.mode) {
            case "nearest":
              return `input_indices = calculateInputIndicesFromOutputIndices(output_indices);
                if (checkInputIndices(input_indices)) {
                  output[global_idx] = ${input.getByIndices("input_indices")};
                } else {
                  output[global_idx] = ${attributes.extrapolationValue};
                }`;
            case "linear":
              return `output[global_idx] = ${inputShape.length === 2 || inputShape.length === 4 ? "bilinearInterpolation" : "trilinearInterpolation"}(output_indices);`;
            case "cubic":
              return "output[global_idx] = bicubicInterpolation(output_indices);";
            default:
              throw Error(`Unsupported resize mode: ${attributes.mode}`);
          }
        })()};
`}
      }`;
        return {
          name: "Resize",
          shaderCache: {
            hint: `${attributes.cacheKey}|${opsetVersion}|${scales.length > 0 ? attributes.mode === "cubic" ? scales : scales.length : ""}|${sizes.length > 0 ? sizes : ""}|${roi.length > 0 ? roi : ""}|${noScale}|${attributes.mode === "nearest" ? inputShape.length : inputShape}`,
            inputDependencies: ["rank"]
          },
          getShaderSource,
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: inputTensor.dataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms: [
              { type: 12 /* uint32 */, data: outputSize },
              { type: 1 /* float */, data: scales },
              { type: 1 /* float */, data: roi },
              ...createTensorShapeVariables(inputShape, outputShape)
            ]
          })
        };
      };
      getOpsetVersionFromCustomDataBuffer = (context) => {
        const customDataBuffer = context.customDataBuffer;
        const customDataBuffer32 = new Uint32Array(customDataBuffer, customDataBuffer.byteOffset, 1);
        const opsetVersion = customDataBuffer32[0];
        return opsetVersion;
      };
      resize = (context, attributes) => {
        const scales = [];
        const sizes = [];
        const roi = [];
        const opsetVersion = getOpsetVersionFromCustomDataBuffer(context);
        if (attributes.antialias !== 0) {
          throw Error("Only default value (0) for Antialias attribute is supported");
        }
        validateInputs27(context.inputs, attributes, opsetVersion, scales, sizes, roi);
        context.compute(createResizeProgramInfo(context.inputs[0], attributes, opsetVersion, scales, sizes, roi), {
          inputs: [0]
        });
      };
      parseResizeAttributes = (attributes) => {
        const antialias = attributes.antialias;
        const axes = attributes.axes;
        const coordinateTransformMode = attributes.coordinateTransformMode;
        const cubicCoeffA = attributes.cubicCoeffA;
        const excludeOutside = attributes.excludeOutside !== 0;
        const extrapolationValue = attributes.extrapolationValue;
        const keepAspectRatioPolicy = attributes.keepAspectRatioPolicy;
        const mode = attributes.mode;
        const nearestMode = attributes.nearestMode === "" ? "simple" : attributes.nearestMode;
        return createAttributeWithCacheKey({
          antialias,
          axes,
          coordinateTransformMode,
          cubicCoeffA,
          excludeOutside,
          extrapolationValue,
          keepAspectRatioPolicy,
          mode,
          nearestMode
        });
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/skip-layer-norm.ts
  var validateInputs28, createSkipLayerNormProgramInfo, skipLayerNorm;
  var init_skip_layer_norm = __esm({
    "web/lib/wasm/jsep/webgpu/ops/skip-layer-norm.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_common();
      validateInputs28 = (inputs) => {
        if (!inputs || inputs.length < 3) {
          throw new Error("layerNorm requires at least 3 inputs.");
        }
        const input = inputs[0];
        const skip = inputs[1];
        const gamma = inputs[2];
        if (input.dataType !== skip.dataType || input.dataType !== gamma.dataType) {
          throw new Error("All inputs must have the same data type");
        }
        if (input.dims.length !== 3 && input.dims.length !== 2) {
          throw new Error("Input must be 2D or 3D");
        }
        if (skip.dims.length !== 3 && skip.dims.length !== 2) {
          throw new Error("Skip must be 2D or 3D");
        }
        const hiddenSize = input.dims[input.dims.length - 1];
        const sequenceLength = input.dims[input.dims.length - 2];
        if (skip.dims[skip.dims.length - 1] !== hiddenSize) {
          throw new Error("Skip must have the same hidden size as input");
        }
        if (skip.dims[skip.dims.length - 2] !== sequenceLength) {
          throw new Error("Skip must have the same sequence length as input");
        }
        if (gamma.dims.length !== 1) {
          throw new Error("Gamma must be 1D");
        }
        if (gamma.dims[gamma.dims.length - 1] !== hiddenSize) {
          throw new Error("Gamma must have the same hidden size as input");
        }
        if (inputs.length > 3) {
          const beta = inputs[3];
          if (beta.dims.length !== 1) {
            throw new Error("Beta must be 1D");
          }
          if (beta.dims[beta.dims.length - 1] !== hiddenSize) {
            throw new Error("Beta must have the same hidden size as input");
          }
        }
        if (inputs.length > 4) {
          const bias = inputs[4];
          if (bias.dims.length !== 1) {
            throw new Error("Bias must be 1D");
          }
          if (bias.dims[bias.dims.length - 1] !== hiddenSize) {
            throw new Error("Bias must have the same hidden size as input");
          }
        }
      };
      createSkipLayerNormProgramInfo = (inputs, attributes, outputCount, isTraining) => {
        const simplified = attributes.simplified;
        const inputShape = inputs[0].dims;
        const inputSize = ShapeUtil.size(inputShape);
        const outputShape = inputShape;
        const outputSize = inputSize;
        const hiddenSize = inputShape.slice(-1)[0];
        const meanInvStdDevDim = isTraining ? inputShape.slice(0, -1).concat(1) : [];
        const hasBetaInput = !simplified && inputs.length > 3;
        const hasBiasInput = inputs.length > 4;
        const hasMeanOutput = isTraining && outputCount > 1;
        const hasInvStdDevOutput = isTraining && outputCount > 2;
        const hasInputSkipBiasSumOutput = outputCount > 3;
        const workgroupSize = 64;
        const components = getMaxComponents(hiddenSize);
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 12 /* uint32 */, data: components },
          { type: 12 /* uint32 */, data: hiddenSize },
          { type: 1 /* float */, data: attributes.epsilon }
        ];
        const getShaderSource = (shaderHelper) => {
          const uniformsArray = [
            { name: "output_size", type: "u32" },
            { name: "components", type: "u32" },
            { name: "hidden_size", type: "u32" },
            { name: "epsilon", type: "f32" }
          ];
          const variables = [
            inputVariable("x", inputs[0].dataType, inputs[0].dims, components),
            inputVariable("skip", inputs[1].dataType, inputs[1].dims, components),
            inputVariable("gamma", inputs[2].dataType, inputs[2].dims, components)
          ];
          if (hasBetaInput) {
            variables.push(inputVariable("beta", inputs[3].dataType, inputs[3].dims, components));
          }
          if (hasBiasInput) {
            variables.push(inputVariable("bias", inputs[4].dataType, inputs[4].dims, components));
          }
          variables.push(outputVariable("output", inputs[0].dataType, outputShape, components));
          if (hasMeanOutput) {
            variables.push(outputVariable("mean_output", 1 /* float */, meanInvStdDevDim));
          }
          if (hasInvStdDevOutput) {
            variables.push(outputVariable("inv_std_output", 1 /* float */, meanInvStdDevDim));
          }
          if (hasInputSkipBiasSumOutput) {
            variables.push(outputVariable("input_skip_bias_sum", inputs[0].dataType, outputShape, components));
          }
          const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);
          const vecDataType = tensorTypeToWsglStorageType(1 /* float */, components);
          return `

      ${shaderHelper.registerUniforms(uniformsArray).declareVariables(...variables)}
      var<workgroup> sum_shared : array<${vecDataType}, ${workgroupSize}>;
      var<workgroup> sum_squared_shared : array<${vecDataType}, ${workgroupSize}>;

      ${shaderHelper.mainStart([workgroupSize, 1, 1])}
        let ix = local_id.x;
        let iy = global_id.x / ${workgroupSize};

        let hidden_size_vectorized: u32 = uniforms.hidden_size / uniforms.components;
        var stride = hidden_size_vectorized / ${workgroupSize};
        let offset = ix * stride + iy * hidden_size_vectorized;
        let offset1d = stride * ix;
        if (ix == ${workgroupSize - 1}) {
          stride = hidden_size_vectorized - stride * ix;
        }
        for (var i: u32 = 0; i < stride; i++) {
          let skip_value = skip[offset + i];
          let bias_value = ${hasBiasInput ? "bias[offset1d + i]" : dataType + "(0.0)"};
          let input_value = x[offset + i];
          let value = input_value + skip_value + bias_value;
          ${hasInputSkipBiasSumOutput ? "input_skip_bias_sum[offset + i] = value;" : ""}
          output[offset + i] = value;
          let f32_value = ${castToF32(dataType, components, "value")};
          sum_shared[ix] += f32_value;
          sum_squared_shared[ix] += f32_value * f32_value;
        }
        workgroupBarrier();

        var reduce_size : u32 = ${workgroupSize};
        for (var curr_size = reduce_size >> 1;  curr_size > 0; curr_size = reduce_size >> 1) {
          reduce_size = curr_size + (reduce_size & 1);
          if (ix < curr_size) {
            sum_shared[ix] += sum_shared[ix + reduce_size];
            sum_squared_shared[ix] += sum_squared_shared[ix + reduce_size];
          }
          workgroupBarrier();
        }

        let sum = sum_shared[0];
        let square_sum = sum_squared_shared[0];
        let mean = ${sumVector("sum", components)} / f32(uniforms.hidden_size);
        let inv_std_dev = inverseSqrt(${sumVector("square_sum", components)} / f32(uniforms.hidden_size) ${simplified ? "" : "- mean * mean"} + uniforms.epsilon);
        ${hasMeanOutput ? "mean_output[global_idx] = mean;" : ""}
        ${hasInvStdDevOutput ? "inv_std_output[global_idx] = inv_std_dev;" : ""}

        for (var i: u32 = 0; i < stride; i++) {
          output[offset + i] = (output[offset + i] ${simplified ? "" : `- ${dataType}(mean)`}) *
            ${dataType}(inv_std_dev) * gamma[offset1d + i]
            ${hasBetaInput ? "+ beta[offset1d + i]" : ""};
        }
      }`;
        };
        const outputs = [{ dims: outputShape, dataType: inputs[0].dataType }];
        if (outputCount > 1) {
          outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ });
        }
        if (outputCount > 2) {
          outputs.push({ dims: meanInvStdDevDim, dataType: 1 /* float */ });
        }
        if (outputCount > 3) {
          outputs.push({ dims: inputShape, dataType: inputs[0].dataType });
        }
        return {
          name: "SkipLayerNormalization",
          shaderCache: {
            hint: `${components};${hasMeanOutput};${hasInvStdDevOutput};${hasInputSkipBiasSumOutput}`,
            inputDependencies: inputs.map((_input, _index) => "type")
          },
          getShaderSource,
          getRunData: () => ({
            outputs,
            dispatchGroup: {
              x: Math.ceil(outputSize / hiddenSize)
            },
            programUniforms
          })
        };
      };
      skipLayerNorm = (context, attributes) => {
        const isTraining = false;
        validateInputs28(context.inputs);
        const outputs = [0];
        if (context.outputCount > 1) {
          outputs.push(isTraining ? 1 : -3);
        }
        if (context.outputCount > 2) {
          outputs.push(isTraining ? 2 : -3);
        }
        if (context.outputCount > 3) {
          outputs.push(3);
        }
        context.compute(createSkipLayerNormProgramInfo(context.inputs, attributes, context.outputCount, isTraining), {
          outputs
        });
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/slice.ts
  var validateInputs29, readInput, createSliceAttributesFromInputs, fixStartEndValues, calculateInputIndicesImpl, createSliceProgramInfo, slice, parseSliceAttributes;
  var init_slice = __esm({
    "web/lib/wasm/jsep/webgpu/ops/slice.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_common();
      validateInputs29 = (inputs, attributes) => {
        if (!inputs || inputs.length < 1) {
          throw new Error("too few inputs");
        }
        if (attributes.axes.length !== 0) {
          if (attributes.axes.length !== attributes.starts.length || attributes.axes.length !== attributes.ends.length) {
            throw new Error("axes, starts and ends must have the same length");
          }
        } else if (attributes.starts.length !== attributes.ends.length) {
          throw new Error("starts and ends must have the same length");
        }
        inputs.slice(1).forEach((_, idx) => {
          if (inputs[idx + 1].dataType !== 6 /* int32 */ && inputs[idx + 1].dataType !== 7 /* int64 */) {
            throw new Error(`Input ${idx} must be an array of int32 or int64`);
          }
        });
      };
      readInput = (inputs, idx) => {
        const input = [];
        if (inputs.length > idx) {
          if (inputs[idx].dataType === 7 /* int64 */) {
            inputs[idx].getBigInt64Array().forEach((v) => input.push(Number(v)));
          } else if (inputs[idx].dataType === 6 /* int32 */) {
            inputs[idx].getInt32Array().forEach((v) => input.push(Number(v)));
          } else {
            throw new Error(`Input ${idx} must be an array of int32 or int64`);
          }
        }
        return input;
      };
      createSliceAttributesFromInputs = (inputs, attributes) => {
        if (inputs.length > 1) {
          const starts = readInput(inputs, 1);
          const ends = readInput(inputs, 2);
          let axes = readInput(inputs, 3);
          if (axes.length === 0) {
            axes = [...Array(inputs[0].dims.length).keys()];
          }
          return createAttributeWithCacheKey({ starts, ends, axes });
        } else {
          return attributes;
        }
      };
      fixStartEndValues = (value, index, inputShape, axes, steps) => {
        let newValue = value;
        if (value < 0) {
          newValue += inputShape[axes[index]];
        }
        if (steps[index] < 0) {
          return Math.max(0, Math.min(newValue, inputShape[axes[index]] - 1));
        } else {
          return Math.max(0, Math.min(newValue, inputShape[axes[index]]));
        }
      };
      calculateInputIndicesImpl = (input, output, inputShape) => `fn calculateInputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} {
          var input_indices: ${input.type.indices};
          var carry = 0u;
          for (var i = ${inputShape.length - 1}; i >= 0; i--) {
            let input_shape_i = ${getElementAt("uniforms.input_shape", "i", inputShape.length)};
            let steps_i = ${getElementAt("uniforms.steps", "i", inputShape.length)};
            let signs_i = ${getElementAt("uniforms.signs", "i", inputShape.length)};
            let starts_i = ${getElementAt("uniforms.starts", "i", inputShape.length)};
            var output_index = ${output.indicesGet("output_indices", "i")};
            var input_index = output_index * steps_i + starts_i + carry;
            carry = input_index / input_shape_i;
            input_index = input_index % input_shape_i;
            if (signs_i < 0) {
              input_index = input_shape_i - input_index - 1u + starts_i;
            }
            ${input.indicesSet("input_indices", "i", "input_index")};
          }
          return input_indices;
      }`;
      createSliceProgramInfo = (inputs, attributes) => {
        const inputShape = inputs[0].dims;
        const inputSize = ShapeUtil.size(inputShape);
        const axes = attributes.axes.length > 0 ? ShapeUtil.normalizeAxes(attributes.axes, inputShape.length) : [...Array(inputShape.length).keys()];
        let steps = readInput(inputs, 4);
        steps.forEach(
          (step) => step !== 0 || (() => {
            throw new Error("step cannot be 0");
          })
        );
        if (steps.length === 0) {
          steps = Array(axes.length).fill(1);
        }
        const starts = attributes.starts.map((start, i) => fixStartEndValues(start, i, inputShape, axes, steps));
        const ends = attributes.ends.map((end, i) => fixStartEndValues(end, i, inputShape, axes, steps));
        if (axes.length !== starts.length || axes.length !== ends.length) {
          throw new Error("start, ends and axes should have the same number of elements");
        }
        if (axes.length !== inputShape.length) {
          for (let i = 0; i < inputShape.length; ++i) {
            if (!axes.includes(i)) {
              starts.splice(i, 0, 0);
              ends.splice(i, 0, inputShape[i]);
              steps.splice(i, 0, 1);
            }
          }
        }
        const signs = steps.map((step) => Math.sign(step));
        steps.forEach((step, i, array) => {
          if (step < 0) {
            const numSteps = (ends[i] - starts[i]) / step;
            const newEnd = starts[i];
            const newStart = newEnd + numSteps * steps[i];
            starts[i] = newStart;
            ends[i] = newEnd;
            array[i] = -step;
          }
        });
        const outputShape = inputShape.slice(0);
        axes.forEach((axis, _) => {
          outputShape[axis] = Math.ceil((ends[axis] - starts[axis]) / steps[axis]);
        });
        const outputTensorInfo = { dims: outputShape, dataType: inputs[0].dataType };
        const output = outputVariable("output", inputs[0].dataType, outputShape.length);
        const input = inputVariable("input", inputs[0].dataType, inputs[0].dims.length);
        const outputSize = ShapeUtil.size(outputShape);
        const uniforms = [
          { name: "outputSize", type: "u32" },
          { name: "starts", type: "u32", length: starts.length },
          { name: "signs", type: "i32", length: signs.length },
          { name: "steps", type: "u32", length: steps.length }
        ];
        const programUniforms = [
          { type: 12 /* uint32 */, data: outputSize },
          { type: 12 /* uint32 */, data: starts },
          { type: 6 /* int32 */, data: signs },
          { type: 12 /* uint32 */, data: steps },
          ...createTensorShapeVariables(inputs[0].dims, outputShape)
        ];
        const getShaderSource = (shaderHelper) => `
      ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}
        ${calculateInputIndicesImpl(input, output, inputShape)}
        ${shaderHelper.mainStart()}
          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.outputSize")}
          let output_indices = ${output.offsetToIndices("global_idx")};
          let input_indices = calculateInputIndices(output_indices);
          ${output.setByOffset("global_idx", input.getByIndices("input_indices"))}
      }`;
        return {
          name: "Slice",
          shaderCache: { hint: `${signs.length}_${starts.length}_${steps.length}`, inputDependencies: ["rank"] },
          getShaderSource,
          getRunData: () => ({
            outputs: [outputTensorInfo],
            dispatchGroup: { x: Math.ceil(
              inputSize / 64
              /* workgroup size */
            ) },
            programUniforms
          })
        };
      };
      slice = (context, attributes) => {
        validateInputs29(context.inputs, attributes);
        const updatedAttributes = createSliceAttributesFromInputs(context.inputs, attributes);
        context.compute(createSliceProgramInfo(context.inputs, updatedAttributes), { inputs: [0] });
      };
      parseSliceAttributes = (attributes) => {
        const starts = attributes.starts;
        const ends = attributes.ends;
        const axes = attributes.axes;
        return createAttributeWithCacheKey({ starts, ends, axes });
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/softmax.ts
  var validateInputs30, createSoftmaxProgramInfo, softmax, parseSoftmaxAttributes;
  var init_softmax = __esm({
    "web/lib/wasm/jsep/webgpu/ops/softmax.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_attribute_with_cache_key();
      init_transpose();
      init_common();
      validateInputs30 = (inputs) => {
        if (!inputs || inputs.length !== 1) {
          throw new Error("Softmax op requires 1 input.");
        }
      };
      createSoftmaxProgramInfo = (context, attributes) => {
        const input = context.inputs[0];
        const inputShape = input.dims;
        const outputSize = ShapeUtil.size(inputShape);
        const inputRank = inputShape.length;
        const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);
        const isTransposeRequired = axis < inputShape.length - 1;
        let transposedInput;
        let perm = [];
        if (isTransposeRequired) {
          perm = Array.from({ length: inputRank }, (_, i) => i);
          perm[axis] = inputRank - 1;
          perm[inputRank - 1] = axis;
          transposedInput = context.compute(createTransposeProgramInfo(input, perm), {
            inputs: [input],
            outputs: [-1]
          })[0];
        } else {
          transposedInput = input;
        }
        const transposedInputShape = transposedInput.dims;
        const cols = transposedInputShape[inputRank - 1];
        const rows = outputSize / cols;
        const components = getMaxComponents(cols);
        const packedCols = cols / components;
        let WG = 64;
        if (rows === 1) {
          WG = 256;
        }
        const maxVector = (name, components2) => {
          if (components2 === 4) {
            return `max(max(${name}.x, ${name}.y), max(${name}.z, ${name}.w))`;
          } else if (components2 === 2) {
            return `max(${name}.x, ${name}.y)`;
          } else if (components2 === 3) {
            return `max(max(${name}.x, ${name}.y), ${name}.z)`;
          }
          return name;
        };
        const x = inputVariable("x", transposedInput.dataType, transposedInput.dims, components);
        const output = outputVariable("result", transposedInput.dataType, transposedInput.dims, components);
        const valueType = x.type.value;
        const threadMaxDecl = tensorTypeToWsglStorageType(transposedInput.dataType) === "f32" ? `var threadMax = ${valueType}(-3.4028234663852886e+38f);` : `var threadMax = ${valueType}(-65504.0h);`;
        const getShaderSource = (shaderHelper) => `
      var<workgroup> rowMaxShared : ${valueType};
      var<workgroup> rowSumShared : ${valueType};
      var<workgroup> threadShared : array<${valueType}, ${WG}>;

      fn getValue(row: i32, col: i32, row_stride: i32) -> ${valueType} {
        let index = row * row_stride + col;
        return x[index];
      }

      fn setValue(row: i32, col: i32, row_stride: i32, value: ${valueType}) {
        let index = row * row_stride + col;
        result[index] = value;
      }
      ${shaderHelper.registerUniform("packedCols", "i32").declareVariables(x, output)}
      ${shaderHelper.mainStart(WG)}
        let gindex = i32(global_idx);
        let lindex = i32(local_idx);
        const wg = ${WG};
        let row = gindex / wg;
        let cols = uniforms.packedCols;
        let row_stride : i32 = uniforms.packedCols;

        // find the rows max
        ${threadMaxDecl}
        for (var col = lindex; col < cols; col += wg) {
          let value = getValue(row, col, row_stride);
          threadMax = max(threadMax, value);
        }
        if (lindex < cols) {
          threadShared[lindex] = threadMax;
        }
        workgroupBarrier();

        var reduceSize = min(cols, wg);
        for (var currSize = reduceSize >> 1;  currSize > 0; currSize = reduceSize >> 1) {
          reduceSize = currSize + (reduceSize & 1);
          if (lindex < currSize) {
            threadShared[lindex] = max(threadShared[lindex], threadShared[lindex + reduceSize]);
          }
          workgroupBarrier();
        }
        if (lindex == 0) {
          rowMaxShared = ${valueType}(${maxVector("threadShared[0]", components)});
        }
        workgroupBarrier();

        // find the rows sum
        var threadSum = ${valueType}(0.0);
        for (var col = lindex; col < cols; col += wg) {
          let subExp = exp(getValue(row, col, row_stride) - rowMaxShared);
          threadSum += subExp;
        }
        threadShared[lindex] = threadSum;
        workgroupBarrier();

        for (var currSize = wg >> 1;  currSize > 0; currSize = currSize >> 1) {
          if (lindex < currSize) {
            threadShared[lindex] = threadShared[lindex] + threadShared[lindex + currSize];
          }
          workgroupBarrier();
        }
        if (lindex == 0) {
          rowSumShared = ${valueType}(${sumVector("threadShared[0]", components)});
        }
        workgroupBarrier();

        // calculate final value for each element in the row
        for (var col = lindex; col < cols; col += wg) {
          var value = exp(getValue(row, col, row_stride) - rowMaxShared) / rowSumShared;
          // max operation protects against NaN since all values should be >=0
          value = max(value, ${valueType}(0.0));
          setValue(row, col, row_stride, value);
        }
      }`;
        const result = context.compute(
          {
            name: "Softmax",
            // Note that in JSEP, WG size is not included in cache by default, but WebGPU EP it is.
            shaderCache: { hint: `${components};${WG}`, inputDependencies: ["type"] },
            getRunData: () => ({
              outputs: [{ dims: transposedInputShape, dataType: transposedInput.dataType }],
              dispatchGroup: { x: rows },
              programUniforms: [{ type: 6 /* int32 */, data: packedCols }]
            }),
            getShaderSource
          },
          {
            inputs: [transposedInput],
            outputs: [isTransposeRequired ? -1 : 0]
          }
        )[0];
        if (isTransposeRequired) {
          context.compute(createTransposeProgramInfo(result, perm), {
            inputs: [result]
          });
        }
      };
      softmax = (context, attributes) => {
        validateInputs30(context.inputs);
        createSoftmaxProgramInfo(context, attributes);
      };
      parseSoftmaxAttributes = (attributes) => createAttributeWithCacheKey({ axis: attributes.axis });
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/tile.ts
  var getRepeats, validateInputs31, getOutputShape2, createTileProgramInfo, tile;
  var init_tile = __esm({
    "web/lib/wasm/jsep/webgpu/ops/tile.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_common();
      getRepeats = (repeatsTensorView) => Array.from(repeatsTensorView.getBigInt64Array(), Number);
      validateInputs31 = (inputs) => {
        if (!inputs || inputs.length !== 2) {
          throw new Error("Tile requires 2 inputs.");
        }
        if (inputs[0].dataType !== 1 /* float */ && inputs[0].dataType !== 10 /* float16 */ && inputs[0].dataType !== 6 /* int32 */ && inputs[0].dataType !== 12 /* uint32 */) {
          throw new Error("Tile only support float, float16, int32, and uint32 data types");
        }
        if (inputs[1].dataType !== 7 /* int64 */) {
          throw new Error("Tile `repeats` input should be of int64 data type");
        }
        if (inputs[1].dims.length !== 1) {
          throw new Error("Tile `repeats` input should be 1-D");
        }
        const repeats = getRepeats(inputs[1]);
        if (repeats.length !== inputs[0].dims.length) {
          throw new Error("Tile `repeats` input should have same number of elements as rank of input data tensor");
        }
      };
      getOutputShape2 = (inputShape, repeats) => {
        const outputShape = [];
        for (let i = 0; i < inputShape.length; ++i) {
          outputShape.push(inputShape[i] * repeats[i]);
        }
        return outputShape;
      };
      createTileProgramInfo = (inputs, shape) => {
        const inputShape = inputs[0].dims;
        const repeats = shape == null ? getRepeats(inputs[1]) : shape;
        const outputShape = getOutputShape2(inputShape, repeats);
        const outputSize = ShapeUtil.size(outputShape);
        const dataType = inputs[0].dataType;
        const input = inputVariable("input", dataType, inputShape.length);
        const output = outputVariable("output", dataType, outputShape.length);
        const getShaderSource = (shaderHelper) => `
      const inputShape = ${input.indices(...inputShape)};
      ${shaderHelper.registerUniform("output_size", "u32").declareVariables(input, output)}
      ${shaderHelper.mainStart()}
      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.output_size")}
      let output_indices = ${output.offsetToIndices("global_idx")};
      var input_indices: ${input.type.indices};
      for (var i = 0; i < ${inputShape.length}; i++) {
        let input_dim_i = ${input.indicesGet("uniforms.input_shape", "i")};
        let input_dim_value = ${output.indicesGet("output_indices", "i")}  % input_dim_i;

        ${input.indicesSet("input_indices", "i", "input_dim_value")}
      }
      ${output.setByOffset("global_idx", input.getByIndices("input_indices"))}
    }`;
        return {
          name: "Tile",
          shaderCache: { hint: `${repeats}`, inputDependencies: ["rank"] },
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64
              /* workgroup size */
            ) },
            programUniforms: [
              { type: 12 /* uint32 */, data: outputSize },
              ...createTensorShapeVariables(inputs[0].dims, outputShape)
            ]
          }),
          getShaderSource
        };
      };
      tile = (context) => {
        validateInputs31(context.inputs);
        context.compute(createTileProgramInfo(context.inputs), { inputs: [0] });
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/ops/where.ts
  var createWhereOpProgramShader, createWhereOpProgramInfo, where;
  var init_where = __esm({
    "web/lib/wasm/jsep/webgpu/ops/where.ts"() {
      "use strict";
      init_wasm_common();
      init_util();
      init_common();
      createWhereOpProgramShader = (shaderHelper, inputs, dimsOutput, isBroadcast, typeOutput) => {
        const output = outputVariable("output_data", typeOutput, dimsOutput.length, 4);
        const a = inputVariable("a_data", inputs[1].dataType, inputs[1].dims.length, 4);
        const b = inputVariable("b_data", inputs[2].dataType, inputs[2].dims.length, 4);
        const c = inputVariable("c_data", inputs[0].dataType, inputs[0].dims.length, 4);
        let assignment;
        const expression = (a2, b2, c2) => `select(${b2}, ${a2}, ${c2})`;
        if (!isBroadcast) {
          assignment = output.setByOffset(
            "global_idx",
            expression(a.getByOffset("global_idx"), b.getByOffset("global_idx"), c.getByOffset("global_idx"))
          );
        } else {
          const singleAssignment = (resStr, x, typeCast = "") => {
            const expressionA = `a_data[index_a${x}][component_a${x}]`;
            const expressionB = `b_data[index_b${x}][component_b${x}]`;
            const expressionC = `bool(c_data[index_c${x}] & (0xffu << (component_c${x} * 8)))`;
            return `
            let output_indices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)};
            let offset_a${x} = ${a.broadcastedIndicesToOffset(`output_indices${x}`, output)};
            let offset_b${x} = ${b.broadcastedIndicesToOffset(`output_indices${x}`, output)};
            let offset_c${x} = ${c.broadcastedIndicesToOffset(`output_indices${x}`, output)};
            let index_a${x} = offset_a${x} / 4u;
            let index_b${x} = offset_b${x} / 4u;
            let index_c${x} = offset_c${x} / 4u;
            let component_a${x} = offset_a${x} % 4u;
            let component_b${x} = offset_b${x} % 4u;
            let component_c${x} = offset_c${x} % 4u;
            ${resStr}[${x}] = ${typeCast}(${expression(expressionA, expressionB, expressionC)});
          `;
          };
          if (typeOutput === 9 /* bool */) {
            assignment = `
            var data = vec4<u32>(0);
            ${singleAssignment("data", 0, "u32")}
            ${singleAssignment("data", 1, "u32")}
            ${singleAssignment("data", 2, "u32")}
            ${singleAssignment("data", 3, "u32")}
            output_data[global_idx] = dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(data));`;
          } else {
            assignment = `
            ${singleAssignment("output_data[global_idx]", 0)}
            ${singleAssignment("output_data[global_idx]", 1)}
            ${singleAssignment("output_data[global_idx]", 2)}
            ${singleAssignment("output_data[global_idx]", 3)}
          `;
          }
        }
        return `
        ${shaderHelper.registerUniform("vec_size", "u32").declareVariables(c, a, b, output)}
        ${shaderHelper.mainStart()}
        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes("uniforms.vec_size")}
        ${assignment}
      }`;
      };
      createWhereOpProgramInfo = (inputs) => {
        const dimsA = inputs[1].dims;
        const dimsB = inputs[2].dims;
        const dimsC = inputs[0].dims;
        const outputDataType = inputs[1].dataType;
        const isBroadcast = !(ShapeUtil.areEqual(dimsA, dimsB) && ShapeUtil.areEqual(dimsB, dimsC));
        let outputShape = dimsA;
        let outputSize = ShapeUtil.size(dimsA);
        if (isBroadcast) {
          const calculatedShape = BroadcastUtil.calcShape(BroadcastUtil.calcShape(dimsA, dimsB, false), dimsC, false);
          if (!calculatedShape) {
            throw new Error("Can't perform where op on the given tensors");
          }
          outputShape = calculatedShape;
          outputSize = ShapeUtil.size(outputShape);
        }
        const vecSize = Math.ceil(outputSize / 4);
        return {
          name: "Where",
          shaderCache: { inputDependencies: ["rank", "rank", "rank"] },
          getShaderSource: (shaderHelper) => createWhereOpProgramShader(shaderHelper, inputs, outputShape, isBroadcast, outputDataType),
          getRunData: () => ({
            outputs: [{ dims: outputShape, dataType: outputDataType }],
            dispatchGroup: { x: Math.ceil(
              outputSize / 64 / 4
              /* vec size */
            ) },
            programUniforms: [
              { type: 12 /* uint32 */, data: vecSize },
              ...createTensorShapeVariables(dimsC, dimsA, dimsB, outputShape)
            ]
          })
        };
      };
      where = (context) => {
        context.compute(createWhereOpProgramInfo(context.inputs));
      };
    }
  });

  // web/lib/wasm/jsep/webgpu/op-resolve-rules.ts
  var WEBGPU_OP_RESOLVE_RULES;
  var init_op_resolve_rules = __esm({
    "web/lib/wasm/jsep/webgpu/op-resolve-rules.ts"() {
      "use strict";
      init_argminmax();
      init_attention();
      init_batch_norm();
      init_bias_add();
      init_bias_split_gelu();
      init_binary_op();
      init_concat();
      init_conv();
      init_conv_transpose();
      init_cumsum();
      init_depth_to_space();
      init_einsum();
      init_expand();
      init_fast_gelu();
      init_gather();
      init_gather_nd();
      init_gather_block_quantized();
      init_gather_elements();
      init_gemm();
      init_grid_sample();
      init_group_query_attention();
      init_instance_norm();
      init_layer_norm();
      init_matmul();
      init_matmulnbits();
      init_multihead_attention();
      init_pad();
      init_pool();
      init_quantize_linear();
      init_range();
      init_scatter_nd();
      init_reduce();
      init_resize();
      init_rotary_embedding();
      init_skip_layer_norm();
      init_slice();
      init_softmax();
      init_split();
      init_tile();
      init_transpose();
      init_unary_op();
      init_where();
      WEBGPU_OP_RESOLVE_RULES = /* @__PURE__ */ new Map([
        ["Abs", [abs]],
        ["Acos", [acos]],
        ["Acosh", [acosh]],
        ["Add", [add]],
        ["ArgMax", [argMax, parseArgMinMaxAttributes]],
        ["ArgMin", [argMin, parseArgMinMaxAttributes]],
        ["Asin", [asin]],
        ["Asinh", [asinh]],
        ["Atan", [atan]],
        ["Atanh", [atanh]],
        ["Attention", [attention]],
        // TODO: support new attributes for AveragePool-10
        ["AveragePool", [averagePool, parseAveragePoolAttributes]],
        ["BatchNormalization", [batchNorm]],
        ["BiasAdd", [biasAdd]],
        ["BiasSplitGelu", [biasSplitGelu]],
        ["Cast", [cast, parseCastAttributes]],
        ["Ceil", [ceil]],
        ["Clip", [clip]],
        ["Concat", [concat, parseConcatAttributes]],
        ["Conv", [conv, parseConvAttributes]],
        ["ConvTranspose", [convTranspose, parseConvTransposeAttributes]],
        ["Cos", [cos]],
        ["Cosh", [cosh]],
        ["CumSum", [cumsum, parseCumSumAttributes]],
        ["DepthToSpace", [depthToSpace, parseDepthToSpaceAttributes]],
        ["DequantizeLinear", [dequantizeLinear, parseDequantizeLinearAttributes]],
        ["Div", [div]],
        ["Einsum", [einsum, parseEinsumAttributes]],
        ["Elu", [elu, parseAlphaAttributes]],
        ["Equal", [equal]],
        ["Erf", [erf]],
        ["Exp", [exp]],
        ["Expand", [expand]],
        ["FastGelu", [fastGelu2]],
        ["Floor", [floor]],
        ["FusedConv", [conv, parseConvAttributes]],
        ["Gather", [gather, parseGatherAttributes]],
        ["GatherElements", [gatherElements, parseGatherElementsAttributes]],
        ["GatherBlockQuantized", [gatherBlockQuantized, parseGatherBlockQuantizedAttributes]],
        ["GatherND", [gatherND, parseGatherNDAttributes]],
        ["Gelu", [gelu]],
        ["Gemm", [gemm, parseGemmAttributes]],
        ["GlobalAveragePool", [globalAveragePool, parseGlobalAveragePoolAttributes]],
        ["GlobalMaxPool", [globalMaxPool, parseGlobalMaxPoolAttributes]],
        ["Greater", [greater]],
        ["GreaterOrEqual", [greaterOrEqual]],
        ["GridSample", [gridSample, parseGridSampleAttributes]],
        ["GroupQueryAttention", [groupQueryAttention]],
        ["HardSigmoid", [hardSigmoid, parseHardSigmoidAttributes]],
        ["InstanceNormalization", [instanceNorm]],
        ["LayerNormalization", [layerNorm]],
        ["LeakyRelu", [leakyRelu, parseAlphaAttributes]],
        ["Less", [less]],
        ["LessOrEqual", [lessOrEqual]],
        ["Log", [log]],
        ["MatMul", [matMul]],
        ["MatMulNBits", [matMulNBits, parseMatMulNBitsAttributes]],
        // TODO: support new attributes for MaxPool-8 and MaxPool-10
        ["MaxPool", [maxPool, parseMaxPoolAttributes]],
        ["Mul", [mul]],
        ["MultiHeadAttention", [multiHeadAttention, parseMultiHeadAttentionAttributes]],
        ["Neg", [neg]],
        ["Not", [not]],
        ["Pad", [pad]],
        ["Pow", [pow]],
        ["QuickGelu", [quickgelu, parseAlphaAttributes]],
        ["Range", [range]],
        ["Reciprocal", [reciprocal]],
        ["ReduceMin", [reduceMin]],
        ["ReduceMean", [reduceMean]],
        ["ReduceMax", [reduceMax]],
        ["ReduceSum", [reduceSum]],
        ["ReduceProd", [reduceProd]],
        ["ReduceL1", [reduceL1]],
        ["ReduceL2", [reduceL2]],
        ["ReduceLogSum", [reduceLogSum]],
        ["ReduceLogSumExp", [reduceLogSumExp]],
        ["ReduceSumSquare", [reduceSumSquare]],
        ["Relu", [relu]],
        ["Resize", [resize, parseResizeAttributes]],
        ["RotaryEmbedding", [rotaryEmbedding]],
        ["ScatterND", [scatterND, parseScatterNDAttributes]],
        ["Sigmoid", [sigmoid]],
        ["Sin", [sin]],
        ["Sinh", [sinh]],
        ["Slice", [slice, parseSliceAttributes]],
        ["SkipLayerNormalization", [skipLayerNorm]],
        ["Split", [split, parseSplitAttributes]],
        ["Sqrt", [sqrt]],
        ["Softmax", [softmax, parseSoftmaxAttributes]],
        ["Sub", [sub]],
        ["Tan", [tan]],
        ["Tanh", [tanh]],
        ["ThresholdedRelu", [thresholdedRelu, parseAlphaAttributes]],
        ["Tile", [tile]],
        ["Transpose", [transpose, parseTransposeAttributes]],
        ["Where", [where]]
      ]);
    }
  });

  // web/lib/wasm/jsep/webgpu/program-manager.ts
  var ProgramManager;
  var init_program_manager = __esm({
    "web/lib/wasm/jsep/webgpu/program-manager.ts"() {
      "use strict";
      init_esm();
      init_log();
      init_common();
      ProgramManager = class {
        constructor(backend) {
          this.backend = backend;
          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, outputs, dispatchGroup, uniformBufferBinding) {
          TRACE_FUNC_BEGIN(buildArtifact.programInfo.name);
          const device = this.backend.device;
          const computePassEncoder = this.backend.getComputePassEncoder();
          this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2);
          const entries = [];
          for (const input of inputs) {
            entries.push({ binding: entries.length, resource: { buffer: input.buffer } });
          }
          for (const output of outputs) {
            entries.push({ binding: entries.length, resource: { buffer: output.buffer } });
          }
          if (uniformBufferBinding) {
            entries.push({ binding: entries.length, resource: uniformBufferBinding });
          }
          const bindGroup = device.createBindGroup({
            layout: buildArtifact.computePipeline.getBindGroupLayout(0),
            entries,
            label: buildArtifact.programInfo.name
          });
          if (this.backend.sessionStatus === "capturing") {
            const commandInfo = {
              kernelId: this.backend.currentKernelId,
              computePipeline: buildArtifact.computePipeline,
              bindGroup,
              dispatchGroup
            };
            const sessionCommandList = this.backend.capturedCommandList.get(this.backend.currentSessionId);
            sessionCommandList.push(commandInfo);
          }
          computePassEncoder.setPipeline(buildArtifact.computePipeline);
          computePassEncoder.setBindGroup(0, bindGroup);
          computePassEncoder.dispatchWorkgroups(...dispatchGroup);
          this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2 + 1);
          this.backend.pendingDispatchNumber++;
          if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber || this.backend.queryType === "at-passes") {
            this.backend.endComputePass();
          }
          if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber) {
            this.backend.flush();
          }
          TRACE_FUNC_END(buildArtifact.programInfo.name);
        }
        dispose() {
        }
        build(programInfo, normalizedDispatchGroupSize) {
          TRACE_FUNC_BEGIN(programInfo.name);
          const device = this.backend.device;
          const enableDirectives = [];
          const extensionsInfo = [
            { feature: "shader-f16", extension: "f16" },
            { feature: "subgroups", extension: "subgroups" }
          ];
          extensionsInfo.forEach((info) => {
            if (device.features.has(info.feature)) {
              enableDirectives.push(`enable ${info.extension};`);
            }
          });
          const shaderHelper = createShaderHelper(normalizedDispatchGroupSize, this.backend.device.limits);
          const userCode = programInfo.getShaderSource(shaderHelper);
          const code = `${enableDirectives.join("\n")}
${shaderHelper.additionalImplementations}
${userCode}`;
          const shaderModule = device.createShaderModule({ code, label: programInfo.name });
          LOG_DEBUG("verbose", () => `[WebGPU] ${programInfo.name} shader code: ${code}`);
          const computePipeline = device.createComputePipeline({
            compute: { module: shaderModule, entryPoint: "main" },
            layout: "auto",
            label: programInfo.name
          });
          TRACE_FUNC_END(programInfo.name);
          return { programInfo, computePipeline, uniformVariablesInfo: shaderHelper.variablesInfo };
        }
        normalizeDispatchGroupSize(dispatchGroup) {
          const x = typeof dispatchGroup === "number" ? dispatchGroup : dispatchGroup.x;
          const y = typeof dispatchGroup === "number" ? 1 : dispatchGroup.y || 1;
          const z = typeof dispatchGroup === "number" ? 1 : dispatchGroup.z || 1;
          const limitPerDimension = this.backend.device.limits.maxComputeWorkgroupsPerDimension;
          if (x <= limitPerDimension && y <= limitPerDimension && z <= limitPerDimension) {
            return [x, y, z];
          }
          const size = x * y * z;
          let dispatchAverage = Math.ceil(Math.sqrt(size));
          if (dispatchAverage > limitPerDimension) {
            dispatchAverage = Math.ceil(Math.cbrt(size));
            if (dispatchAverage > limitPerDimension) {
              throw new Error("Total dispatch size exceeds WebGPU maximum.");
            }
            return [dispatchAverage, dispatchAverage, dispatchAverage];
          } else {
            return [dispatchAverage, dispatchAverage, 1];
          }
        }
      };
    }
  });

  // web/lib/wasm/jsep/backend-webgpu.ts
  var backend_webgpu_exports = {};
  __export(backend_webgpu_exports, {
    WebGpuBackend: () => WebGpuBackend
  });
  var getProgramInputTensorInfoDependencyKey, getProgramInfoUniqueKey, AdapterInfoImpl, WebGpuBackend;
  var init_backend_webgpu = __esm({
    "web/lib/wasm/jsep/backend-webgpu.ts"() {
      "use strict";
      init_esm();
      init_wasm_common();
      init_log();
      init_tensor_view();
      init_gpu_data_manager();
      init_op_resolve_rules();
      init_program_manager();
      getProgramInputTensorInfoDependencyKey = (inputTensors, inputDependencies) => {
        if (inputDependencies.length !== inputTensors.length) {
          throw new Error(
            `inputDependencies length ${inputDependencies.length} is not equal to inputTensors length ${inputTensors.length}.`
          );
        }
        const inputInfos = [];
        for (let i = 0; i < inputTensors.length; ++i) {
          const type = inputTensors[i].dataType;
          switch (inputDependencies[i]) {
            case "none": {
              inputInfos.push("");
              break;
            }
            case "type": {
              inputInfos.push(`${type}`);
              break;
            }
            case "rank": {
              const rank = inputTensors[i].dims.length;
              inputInfos.push(`${type};${rank}`);
              break;
            }
            case "dims": {
              const dims = inputTensors[i].dims.join(",");
              inputInfos.push(`${type};${dims}`);
              break;
            }
            default:
              throw new Error(`unsupported input dependency: ${inputDependencies[i]}`);
          }
        }
        return inputInfos.join("|");
      };
      getProgramInfoUniqueKey = (programInfo, inputTensors, is1DimensionDispatch) => {
        let key = programInfo.name;
        if (programInfo.shaderCache?.hint) {
          key += "[" + programInfo.shaderCache.hint + "]";
        }
        key += ":" + is1DimensionDispatch + `:${getProgramInputTensorInfoDependencyKey(
          inputTensors,
          programInfo.shaderCache?.inputDependencies ?? new Array(inputTensors.length).fill("dims")
        )}`;
        return key;
      };
      AdapterInfoImpl = class {
        constructor(adapterInfo) {
          if (adapterInfo) {
            this.architecture = adapterInfo.architecture;
            this.vendor = adapterInfo.vendor;
          }
        }
        isArchitecture(architecture) {
          return this.architecture === architecture;
        }
        isVendor(vendor) {
          return this.vendor === vendor;
        }
      };
      WebGpuBackend = class {
        constructor() {
          /**
           * representing the session ID of which is currently being run.
           * `null` means no session is being run.
           * only valid when session.run is executed.
           */
          this.currentSessionId = null;
          /**
           * representing the kernel ID of which is currently being computed (CPU code perspective).
           * `null` means no kernel is being computed.
           * only one kernel can be computed at a moment.
           */
          this.currentKernelId = null;
          this.commandEncoder = null;
          this.computePassEncoder = null;
          this.maxDispatchNumber = 16;
          this.pendingDispatchNumber = 0;
          // info of kernels pending submission for a single batch
          this.pendingKernels = [];
          // queryReadBuffer -> pendingKernels mapping for all the batches
          this.pendingQueries = /* @__PURE__ */ new Map();
          this.sessionStatus = "default";
          /**
           * a SessionID -> CommandInfo[] mapping. It's used to record all GPU commands for corresponding session.
           */
          this.capturedCommandList = /* @__PURE__ */ new Map();
          /**
           * a SessionID -> PendingKernelInfo[] mapping for profiling.
           */
          this.capturedPendingKernels = /* @__PURE__ */ new Map();
          /**
           * a SessionID -> a Map of (InputOutputIndex -> [ID, GPUBuffer]) mapping.
           */
          this.sessionExternalDataMapping = /* @__PURE__ */ new Map();
        }
        /**
         * get the custom data of the current kernel
         */
        get currentKernelCustomData() {
          if (this.currentKernelId === null) {
            throw new Error("currentKernelCustomData(): currentKernelId is null. (should not happen)");
          }
          let data = this.kernelCustomData.get(this.currentKernelId);
          if (!data) {
            data = {};
            this.kernelCustomData.set(this.currentKernelId, data);
          }
          return data;
        }
        async initialize(env3, adapter) {
          this.env = env3;
          const requiredFeatures = [];
          const deviceDescriptor = {
            requiredLimits: {
              maxComputeWorkgroupStorageSize: adapter.limits.maxComputeWorkgroupStorageSize,
              maxComputeWorkgroupsPerDimension: adapter.limits.maxComputeWorkgroupsPerDimension,
              maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,
              maxBufferSize: adapter.limits.maxBufferSize,
              maxComputeInvocationsPerWorkgroup: adapter.limits.maxComputeInvocationsPerWorkgroup,
              maxComputeWorkgroupSizeX: adapter.limits.maxComputeWorkgroupSizeX,
              maxComputeWorkgroupSizeY: adapter.limits.maxComputeWorkgroupSizeY,
              maxComputeWorkgroupSizeZ: adapter.limits.maxComputeWorkgroupSizeZ
            },
            requiredFeatures
          };
          const requireFeatureIfAvailable = (feature) => adapter.features.has(feature) && requiredFeatures.push(feature) && true;
          if (!requireFeatureIfAvailable("chromium-experimental-timestamp-query-inside-passes")) {
            requireFeatureIfAvailable("timestamp-query");
          }
          requireFeatureIfAvailable("shader-f16");
          requireFeatureIfAvailable("subgroups");
          this.device = await adapter.requestDevice(deviceDescriptor);
          this.adapterInfo = new AdapterInfoImpl(adapter.info || await adapter.requestAdapterInfo());
          this.gpuDataManager = createGpuDataManager(this);
          this.programManager = new ProgramManager(this);
          this.kernels = /* @__PURE__ */ new Map();
          this.kernelPersistentData = /* @__PURE__ */ new Map();
          this.kernelCustomData = /* @__PURE__ */ new Map();
          configureLogger(env3.logLevel, !!env3.debug);
          this.device.onuncapturederror = (ev) => {
            if (ev.error instanceof GPUValidationError) {
              console.error(`An uncaught WebGPU validation error was raised: ${ev.error.message}`);
            }
          };
          Object.defineProperty(this.env.webgpu, "device", {
            value: this.device,
            writable: false,
            enumerable: true,
            configurable: true
            // Allow deletion when device is destroyed
          });
          Object.defineProperty(this.env.webgpu, "adapter", {
            value: adapter,
            writable: false,
            enumerable: true,
            configurable: false
          });
          this.setQueryType();
        }
        dispose() {
          if (typeof this.querySet !== "undefined") {
            this.querySet.destroy();
          }
          this.gpuDataManager.dispose();
          if (this.device && this.env?.webgpu) {
            void this.device.lost.then(() => {
              delete this.env.webgpu.device;
            });
          }
        }
        getCommandEncoder() {
          if (!this.commandEncoder) {
            this.commandEncoder = this.device.createCommandEncoder();
          }
          return this.commandEncoder;
        }
        getComputePassEncoder() {
          if (!this.computePassEncoder) {
            const commandEncoder = this.getCommandEncoder();
            const computePassDescriptor = {};
            if (this.queryType === "at-passes") {
              computePassDescriptor.timestampWrites = {
                querySet: this.querySet,
                beginningOfPassWriteIndex: this.pendingDispatchNumber * 2,
                endOfPassWriteIndex: this.pendingDispatchNumber * 2 + 1
              };
            }
            this.computePassEncoder = commandEncoder.beginComputePass(computePassDescriptor);
          }
          return this.computePassEncoder;
        }
        endComputePass() {
          if (this.computePassEncoder) {
            this.computePassEncoder.end();
            this.computePassEncoder = null;
          }
        }
        flush() {
          if (!this.commandEncoder) {
            return;
          }
          TRACE_FUNC_BEGIN();
          this.endComputePass();
          let queryReadBuffer;
          if (this.queryType !== "none") {
            this.commandEncoder.resolveQuerySet(
              this.querySet,
              0,
              this.pendingDispatchNumber * 2,
              this.queryResolveBuffer,
              0
            );
            queryReadBuffer = this.device.createBuffer(
              // eslint-disable-next-line no-bitwise
              { size: this.pendingDispatchNumber * 2 * 8, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST }
            );
            this.pendingQueries.set(queryReadBuffer, this.pendingKernels);
            this.pendingKernels = [];
            this.commandEncoder.copyBufferToBuffer(
              this.queryResolveBuffer,
              0,
              queryReadBuffer,
              0,
              this.pendingDispatchNumber * 2 * 8
            );
          }
          this.device.queue.submit([this.commandEncoder.finish()]);
          this.gpuDataManager.refreshPendingBuffers();
          this.commandEncoder = null;
          this.pendingDispatchNumber = 0;
          if (this.queryType !== "none") {
            void queryReadBuffer.mapAsync(GPUMapMode.READ).then(() => {
              const mappedData = new BigUint64Array(queryReadBuffer.getMappedRange());
              const pendingKernels = this.pendingQueries.get(queryReadBuffer);
              for (let i = 0; i < mappedData.length / 2; i++) {
                const pendingKernelInfo = pendingKernels[i];
                const kernelId = pendingKernelInfo.kernelId;
                const kernelInfo = this.kernels.get(kernelId);
                const kernelType = kernelInfo.kernelType;
                const kernelName = kernelInfo.kernelName;
                const programName = pendingKernelInfo.programName;
                const inputTensorViews = pendingKernelInfo.inputTensorViews;
                const outputTensorViews = pendingKernelInfo.outputTensorViews;
                const startTimeU64 = mappedData[i * 2];
                const endTimeU64 = mappedData[i * 2 + 1];
                if (typeof this.queryTimeBase === "undefined") {
                  this.queryTimeBase = startTimeU64;
                }
                const startTime = Number(startTimeU64 - this.queryTimeBase);
                const endTime = Number(endTimeU64 - this.queryTimeBase);
                if (!Number.isSafeInteger(startTime) || !Number.isSafeInteger(endTime)) {
                  throw new RangeError("incorrect timestamp range");
                }
                if (this.env.webgpu.profiling?.ondata) {
                  this.env.webgpu.profiling.ondata({
                    version: 1,
                    inputsMetadata: inputTensorViews.map((value) => ({
                      dims: value.dims,
                      dataType: tensorDataTypeEnumToString(value.dataType)
                    })),
                    outputsMetadata: outputTensorViews.map((value) => ({
                      dims: value.dims,
                      dataType: tensorDataTypeEnumToString(value.dataType)
                    })),
                    kernelId,
                    kernelType,
                    kernelName,
                    programName,
                    startTime,
                    endTime
                  });
                } else {
                  let inputShapes = "";
                  inputTensorViews.forEach((value, i2) => {
                    inputShapes += `input[${i2}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `;
                  });
                  let outputShapes = "";
                  outputTensorViews.forEach((value, i2) => {
                    outputShapes += `output[${i2}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `;
                  });
                  console.log(
                    `[profiling] kernel "${kernelId}|${kernelType}|${kernelName}|${programName}" ${inputShapes}${outputShapes}start time: ${startTime} ns, execution time: ${endTime - startTime} ns`
                  );
                }
                TRACE("GPU", `${programName}::${startTimeU64}::${endTimeU64}`);
              }
              queryReadBuffer.unmap();
              this.pendingQueries.delete(queryReadBuffer);
            });
          }
          TRACE_FUNC_END();
        }
        /**
         * run a WebGPU program.
         * @param program a ProgramInfo instance
         * @param inputTensorViews a TensorView array. each element represents a value already exists in GPU.
         * @param outputIndices an indices array. each element can be either -1 (temporary data), -2 (persistent data) or an
         * index to the kernel's output.
         * @param createKernelOutput a callback function that create a value to kernel's output with the given index
         * @param createIntermediateOutput a callback function that create a value as a intermediate value, either temporary
         * or persistent (owned by the current kernel)
         * @returns a TensorView array representing the result.
         */
        run(program, inputTensorViews, outputIndices, createKernelOutput, createIntermediateOutput, outputCount) {
          TRACE_FUNC_BEGIN(program.name);
          const inputDatas = [];
          for (let i = 0; i < inputTensorViews.length; ++i) {
            const data = inputTensorViews[i].data;
            if (data === 0) {
              continue;
            }
            const gpuData = this.gpuDataManager.get(data);
            if (!gpuData) {
              throw new Error(`no GPU data for input: ${data}`);
            }
            inputDatas.push(gpuData);
          }
          const { outputs, dispatchGroup, programUniforms } = program.getRunData(inputTensorViews);
          const validatedOutputIndices = outputIndices.length === 0 ? outputs.map((_, i) => i) : outputIndices;
          if (validatedOutputIndices.length !== outputs.length) {
            throw new Error(`Output size ${validatedOutputIndices.length} must be equal to ${outputs.length}.`);
          }
          const outputTensorViews = [];
          const outputDatas = [];
          for (let i = 0; i < outputs.length; ++i) {
            if (!Number.isInteger(validatedOutputIndices[i]) || validatedOutputIndices[i] < -3 || validatedOutputIndices[i] >= outputCount) {
              throw new Error(`Invalid output index: ${validatedOutputIndices[i]}`);
            }
            if (validatedOutputIndices[i] === -3) {
              continue;
            }
            const isTemporary = validatedOutputIndices[i] === -1;
            const isPersistent = validatedOutputIndices[i] === -2;
            const tensorView = isTemporary || isPersistent ? createIntermediateOutput(outputs[i].dataType, outputs[i].dims) : createKernelOutput(validatedOutputIndices[i], outputs[i].dataType, outputs[i].dims);
            outputTensorViews.push(tensorView);
            if (tensorView.data === 0) {
              continue;
            }
            const gpuData = this.gpuDataManager.get(tensorView.data);
            if (!gpuData) {
              throw new Error(`no GPU data for output: ${tensorView.data}`);
            }
            if (isTemporary) {
              this.temporaryData.push(gpuData);
            }
            if (isPersistent) {
              let persistentData = this.kernelPersistentData.get(this.currentKernelId);
              if (!persistentData) {
                persistentData = [];
                this.kernelPersistentData.set(this.currentKernelId, persistentData);
              }
              persistentData.push(gpuData);
            }
            outputDatas.push(gpuData);
          }
          if (inputDatas.length !== inputTensorViews.length || outputDatas.length !== outputTensorViews.length) {
            if (outputDatas.length === 0) {
              TRACE_FUNC_END(program.name);
              return outputTensorViews;
            }
            throw new Error(
              `Program ${program.name} has zero-sized tensor(s) in inputs or outputs. This is not supported now.`
            );
          }
          let uniformBufferBinding;
          if (programUniforms) {
            let currentOffset = 0;
            const offsets = [];
            programUniforms.forEach((v) => {
              const data = typeof v.data === "number" ? [v.data] : v.data;
              if (data.length === 0) {
                return;
              }
              const sizeOfElement = v.type === 10 /* float16 */ ? 2 : 4;
              let sizeOfVecOrMat;
              let baseAlignment;
              if (v.type === 10 /* float16 */) {
                baseAlignment = data.length > 4 ? 16 : data.length > 2 ? 8 : data.length * sizeOfElement;
                sizeOfVecOrMat = data.length > 4 ? 16 : sizeOfElement * data.length;
              } else {
                baseAlignment = data.length <= 2 ? data.length * sizeOfElement : 16;
                sizeOfVecOrMat = 16;
              }
              currentOffset = Math.ceil(currentOffset / baseAlignment) * baseAlignment;
              offsets.push(currentOffset);
              const elementPerVecOrMat = v.type === 10 /* float16 */ ? 8 : 4;
              currentOffset += data.length > 4 ? Math.ceil(data.length / elementPerVecOrMat) * sizeOfVecOrMat : data.length * sizeOfElement;
            });
            const maxAlignmentOfField = 16;
            currentOffset = Math.ceil(currentOffset / maxAlignmentOfField) * maxAlignmentOfField;
            const arrayBuffer = new ArrayBuffer(currentOffset);
            programUniforms.forEach((v, i) => {
              const offset = offsets[i];
              const data = typeof v.data === "number" ? [v.data] : v.data;
              if (v.type === 6 /* int32 */) {
                new Int32Array(arrayBuffer, offset, data.length).set(data);
              } else if (v.type === 12 /* uint32 */) {
                new Uint32Array(arrayBuffer, offset, data.length).set(data);
              } else if (v.type === 10 /* float16 */) {
                new Uint16Array(arrayBuffer, offset, data.length).set(data);
              } else if (v.type === 1 /* float */) {
                new Float32Array(arrayBuffer, offset, data.length).set(data);
              } else {
                throw new Error(`Unsupported uniform type: ${tensorDataTypeEnumToString(v.type)}`);
              }
            });
            const uniformBufferData = (
              // eslint-disable-next-line no-bitwise
              this.gpuDataManager.create(currentOffset, GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM)
            );
            this.device.queue.writeBuffer(uniformBufferData.buffer, 0, arrayBuffer, 0, currentOffset);
            this.gpuDataManager.release(uniformBufferData.id);
            uniformBufferBinding = { offset: 0, size: currentOffset, buffer: uniformBufferData.buffer };
          }
          const normalizedDispatchGroup = this.programManager.normalizeDispatchGroupSize(dispatchGroup);
          const is1DimensionDispatch = normalizedDispatchGroup[1] === 1 && normalizedDispatchGroup[2] === 1;
          const key = getProgramInfoUniqueKey(program, inputTensorViews, is1DimensionDispatch);
          let artifact = this.programManager.getArtifact(key);
          if (!artifact) {
            artifact = this.programManager.build(program, normalizedDispatchGroup);
            this.programManager.setArtifact(key, artifact);
            LOG_DEBUG("info", () => `[artifact] key: ${key}, programName: ${program.name}`);
          }
          if (programUniforms && artifact.uniformVariablesInfo) {
            if (programUniforms.length !== artifact.uniformVariablesInfo.length) {
              throw new Error(
                `Uniform variables count mismatch: expect ${artifact.uniformVariablesInfo.length}, got ${programUniforms.length} in program "${artifact.programInfo.name}".`
              );
            }
            for (let i = 0; i < programUniforms.length; i++) {
              const uniform = programUniforms[i];
              const actualType = uniform.type;
              const actualLength = typeof uniform.data === "number" ? 1 : uniform.data.length;
              const [type, length] = artifact.uniformVariablesInfo[i];
              if (actualType !== type || actualLength !== length) {
                throw new Error(
                  `Uniform variable ${i} mismatch: expect type ${type} with size ${length}, got type ${actualType} with size ${actualLength} in program "${artifact.programInfo.name}".`
                );
              }
            }
          }
          LOG_DEBUG(
            "info",
            () => `[ProgramManager] run "${program.name}" (key=${key}) with ${normalizedDispatchGroup[0]}x${normalizedDispatchGroup[1]}x${normalizedDispatchGroup[2]}`
          );
          if (this.queryType !== "none" || this.sessionStatus === "capturing") {
            const pendingKernelInfo = {
              kernelId: this.currentKernelId,
              programName: artifact.programInfo.name,
              inputTensorViews,
              outputTensorViews
            };
            this.pendingKernels.push(pendingKernelInfo);
            if (this.sessionStatus === "capturing") {
              const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId);
              sessionPendingKernels.push(pendingKernelInfo);
            }
          }
          this.programManager.run(artifact, inputDatas, outputDatas, normalizedDispatchGroup, uniformBufferBinding);
          TRACE_FUNC_END(program.name);
          return outputTensorViews;
        }
        upload(gpuDataId, data) {
          this.gpuDataManager.upload(gpuDataId, data);
        }
        memcpy(src, dst) {
          this.gpuDataManager.memcpy(src, dst);
        }
        async download(gpuDataId, getTargetBuffer) {
          await this.gpuDataManager.download(gpuDataId, getTargetBuffer);
        }
        alloc(size) {
          return this.gpuDataManager.create(size).id;
        }
        free(ptr) {
          return this.gpuDataManager.release(ptr);
        }
        createKernel(kernelType, kernelId, attribute, kernelName) {
          const op = WEBGPU_OP_RESOLVE_RULES.get(kernelType);
          if (!op) {
            throw new Error(`kernel not implemented: ${kernelType}`);
          }
          const kernelInfo = {
            kernelType,
            kernelName,
            kernelEntry: op[0],
            attributes: [op[1], attribute]
          };
          this.kernels.set(kernelId, kernelInfo);
        }
        releaseKernel(kernelId) {
          const persistentData = this.kernelPersistentData.get(kernelId);
          if (persistentData) {
            for (const data of persistentData) {
              this.gpuDataManager.release(data.id);
            }
            this.kernelPersistentData.delete(kernelId);
          }
          this.kernelCustomData.delete(kernelId);
          this.kernels.delete(kernelId);
        }
        computeKernel(kernelId, context, errors) {
          const kernel = this.kernels.get(kernelId);
          if (!kernel) {
            throw new Error(`kernel not created: ${kernelId}`);
          }
          const kernelType = kernel.kernelType;
          const kernelName = kernel.kernelName;
          const kernelEntry = kernel.kernelEntry;
          const attributes = kernel.attributes;
          if (this.currentKernelId !== null) {
            throw new Error(`kernel "[${kernelType}] ${kernelName}" is not allowed to be called recursively`);
          }
          this.currentKernelId = kernelId;
          if (attributes[0]) {
            attributes[1] = attributes[0](attributes[1]);
            attributes[0] = void 0;
          }
          LOG_DEBUG("info", () => `[WebGPU] Start to run kernel "[${kernelType}] ${kernelName}"...`);
          const useErrorScope = this.env.debug;
          this.temporaryData = [];
          try {
            if (useErrorScope) {
              this.device.pushErrorScope("validation");
            }
            kernelEntry(context, attributes[1]);
            return 0;
          } catch (e) {
            errors.push(Promise.resolve(`[WebGPU] Kernel "[${kernelType}] ${kernelName}" failed. ${e}`));
            return 1;
          } finally {
            if (useErrorScope) {
              errors.push(
                this.device.popErrorScope().then(
                  (err) => err ? `GPU validation error for kernel "[${kernelType}] ${kernelName}": ${err.message}` : null
                )
              );
            }
            for (const data of this.temporaryData) {
              this.gpuDataManager.release(data.id);
            }
            this.temporaryData = [];
            this.currentKernelId = null;
          }
        }
        // #region external buffer
        registerBuffer(sessionId, index, buffer, size) {
          let sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId);
          if (!sessionInputOutputMapping) {
            sessionInputOutputMapping = /* @__PURE__ */ new Map();
            this.sessionExternalDataMapping.set(sessionId, sessionInputOutputMapping);
          }
          const previousBuffer = sessionInputOutputMapping.get(index);
          const id = this.gpuDataManager.registerExternalBuffer(buffer, size, previousBuffer);
          sessionInputOutputMapping.set(index, [id, buffer]);
          return id;
        }
        unregisterBuffers(sessionId) {
          const sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId);
          if (sessionInputOutputMapping) {
            sessionInputOutputMapping.forEach((bufferInfo) => this.gpuDataManager.unregisterExternalBuffer(bufferInfo[0]));
            this.sessionExternalDataMapping.delete(sessionId);
          }
        }
        getBuffer(gpuDataId) {
          const gpuData = this.gpuDataManager.get(gpuDataId);
          if (!gpuData) {
            throw new Error(`no GPU data for buffer: ${gpuDataId}`);
          }
          return gpuData.buffer;
        }
        createDownloader(gpuBuffer, size, type) {
          return async () => {
            const data = await downloadGpuData(this, gpuBuffer, size);
            return createView(data.buffer, type);
          };
        }
        // #endregion
        writeTimestamp(index) {
          if (this.queryType !== "inside-passes") {
            return;
          }
          this.computePassEncoder.writeTimestamp(this.querySet, index);
        }
        setQueryType() {
          this.queryType = "none";
          if (this.env.webgpu.profiling?.mode === "default" || (typeof this.env.trace === "undefined" ? this.env.wasm.trace : this.env.trace)) {
            if (this.device.features.has("chromium-experimental-timestamp-query-inside-passes")) {
              this.queryType = "inside-passes";
            } else if (this.device.features.has("timestamp-query")) {
              this.queryType = "at-passes";
            }
            if (this.queryType !== "none" && typeof this.querySet === "undefined") {
              this.querySet = this.device.createQuerySet({
                type: "timestamp",
                count: this.maxDispatchNumber * 2
              });
              this.queryResolveBuffer = this.device.createBuffer(
                // eslint-disable-next-line no-bitwise
                { size: this.maxDispatchNumber * 2 * 8, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE }
              );
            }
          }
        }
        captureBegin() {
          LOG_DEBUG("info", "captureBegin");
          if (!this.capturedCommandList.get(this.currentSessionId)) {
            this.capturedCommandList.set(this.currentSessionId, []);
          }
          if (!this.capturedPendingKernels.get(this.currentSessionId)) {
            this.capturedPendingKernels.set(this.currentSessionId, []);
          }
          this.flush();
          this.sessionStatus = "capturing";
        }
        captureEnd() {
          LOG_DEBUG("info", "captureEnd");
          this.flush();
          this.sessionStatus = "default";
        }
        replay() {
          LOG_DEBUG("info", "replay");
          this.sessionStatus = "replaying";
          const sessionCommandList = this.capturedCommandList.get(this.currentSessionId);
          const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId);
          const length = sessionCommandList.length;
          this.pendingKernels = [];
          for (let i = 0; i < length; i++) {
            const computePassEncoder = this.getComputePassEncoder();
            const command = sessionCommandList[i];
            this.writeTimestamp(this.pendingDispatchNumber * 2);
            computePassEncoder.setPipeline(command.computePipeline);
            computePassEncoder.setBindGroup(0, command.bindGroup);
            computePassEncoder.dispatchWorkgroups(...command.dispatchGroup);
            this.writeTimestamp(this.pendingDispatchNumber * 2 + 1);
            this.pendingDispatchNumber++;
            if (this.queryType !== "none") {
              this.pendingKernels.push(sessionPendingKernels[i]);
            }
            if (this.pendingDispatchNumber >= this.maxDispatchNumber || this.queryType === "at-passes") {
              this.endComputePass();
            }
            if (this.pendingDispatchNumber >= this.maxDispatchNumber) {
              this.flush();
            }
          }
          this.flush();
          this.sessionStatus = "default";
        }
        onCreateSession() {
          this.gpuDataManager.onCreateSession();
        }
        onReleaseSession(sessionId) {
          this.unregisterBuffers(sessionId);
          if (this.capturedCommandList.has(sessionId)) {
            this.capturedCommandList.delete(sessionId);
          }
          if (this.capturedPendingKernels.has(sessionId)) {
            this.capturedPendingKernels.delete(sessionId);
          }
          this.gpuDataManager.onReleaseSession(sessionId);
        }
        onRunStart(sessionId) {
          this.currentSessionId = sessionId;
          this.setQueryType();
        }
      };
    }
  });

  // web/lib/wasm/jsep/init.ts
  var init_exports = {};
  __export(init_exports, {
    init: () => init
  });
  var TensorViewImpl, ComputeContextImpl, init;
  var init_init = __esm({
    "web/lib/wasm/jsep/init.ts"() {
      "use strict";
      init_wasm_common();
      init_log();
      init_util();
      init_backend_webnn();
      TensorViewImpl = class _TensorViewImpl {
        constructor(module, dataType, data, dims) {
          this.module = module;
          this.dataType = dataType;
          this.data = data;
          this.dims = dims;
        }
        getFloat32Array() {
          if (this.dataType !== 1 /* float */) {
            throw new Error("Invalid data type");
          }
          const elementCount = ShapeUtil.size(this.dims);
          return elementCount === 0 ? new Float32Array() : new Float32Array(this.module.HEAP8.buffer, this.data, elementCount);
        }
        getBigInt64Array() {
          if (this.dataType !== 7 /* int64 */) {
            throw new Error("Invalid data type");
          }
          const elementCount = ShapeUtil.size(this.dims);
          return elementCount === 0 ? new BigInt64Array() : new BigInt64Array(this.module.HEAP8.buffer, this.data, elementCount);
        }
        getInt32Array() {
          if (this.dataType !== 6 /* int32 */) {
            throw new Error("Invalid data type");
          }
          const elementCount = ShapeUtil.size(this.dims);
          return elementCount === 0 ? new Int32Array() : new Int32Array(this.module.HEAP8.buffer, this.data, elementCount);
        }
        getUint16Array() {
          if (this.dataType !== 10 /* float16 */ && this.dataType !== 4 /* uint16 */) {
            throw new Error("Invalid data type");
          }
          const elementCount = ShapeUtil.size(this.dims);
          return elementCount === 0 ? new Uint16Array() : new Uint16Array(this.module.HEAP8.buffer, this.data, elementCount);
        }
        reshape(newDims) {
          if (ShapeUtil.size(newDims) !== ShapeUtil.size(this.dims)) {
            throw new Error("Invalid new shape");
          }
          return new _TensorViewImpl(this.module, this.dataType, this.data, newDims);
        }
      };
      ComputeContextImpl = class {
        constructor(module, backend, contextDataOffset) {
          this.module = module;
          this.backend = backend;
          this.customDataOffset = 0;
          this.customDataSize = 0;
          this.adapterInfo = backend.adapterInfo;
          const ptrSize = module.PTR_SIZE;
          let dataIndex = contextDataOffset / module.PTR_SIZE;
          const type = ptrSize === 4 ? "i32" : "i64";
          this.opKernelContext = Number(module.getValue(ptrSize * dataIndex++, type));
          const inputCount = Number(module.getValue(ptrSize * dataIndex++, type));
          this.outputCount = Number(module.getValue(ptrSize * dataIndex++, type));
          this.customDataOffset = Number(module.getValue(ptrSize * dataIndex++, "*"));
          this.customDataSize = Number(module.getValue(ptrSize * dataIndex++, type));
          const inputs = [];
          for (let i = 0; i < inputCount; i++) {
            const dataType = Number(module.getValue(ptrSize * dataIndex++, type));
            const data = Number(module.getValue(ptrSize * dataIndex++, "*"));
            const dim = Number(module.getValue(ptrSize * dataIndex++, type));
            const dims = [];
            for (let d = 0; d < dim; d++) {
              dims.push(Number(module.getValue(ptrSize * dataIndex++, type)));
            }
            inputs.push(new TensorViewImpl(module, dataType, data, dims));
          }
          this.inputs = inputs;
        }
        get kernelCustomData() {
          return this.backend.currentKernelCustomData;
        }
        get customDataBuffer() {
          return this.module.HEAPU8.subarray(this.customDataOffset, this.customDataOffset + this.customDataSize);
        }
        compute(program, inputsOutputsMapping) {
          const mappedInputs = inputsOutputsMapping?.inputs?.map((i) => typeof i === "number" ? this.inputs[i] : i) ?? this.inputs;
          const outputIndices = inputsOutputsMapping?.outputs ?? [];
          const createKernelOutput = (index, dataType, dims) => new TensorViewImpl(this.module, dataType, this.output(index, dims), dims);
          const createTemporaryOutput = (dataType, dims) => {
            const bufferSize = calculateTensorSizeInBytes(dataType, dims);
            if (!bufferSize) {
              throw new Error(`Unsupported data type: ${dataType}`);
            }
            const gpuDataId = bufferSize > 0 ? this.backend.gpuDataManager.create(bufferSize).id : 0;
            return new TensorViewImpl(this.module, dataType, gpuDataId, dims);
          };
          return this.backend.run(
            program,
            mappedInputs,
            outputIndices,
            createKernelOutput,
            createTemporaryOutput,
            this.outputCount
          );
        }
        output(index, dims) {
          const stack = this.module.stackSave();
          try {
            const ptrSize = this.module.PTR_SIZE;
            const type = ptrSize === 4 ? "i32" : "i64";
            const data = this.module.stackAlloc(
              (1 + dims.length) * ptrSize
              /* sizeof(size_t) */
            );
            this.module.setValue(data, dims.length, type);
            for (let i = 0; i < dims.length; i++) {
              this.module.setValue(data + ptrSize * (i + 1), dims[i], type);
            }
            return this.module._JsepOutput(this.opKernelContext, index, data);
          } catch (e) {
            throw new Error(
              `Failed to generate kernel's output[${index}] with dims [${dims}]. If you are running with pre-allocated output, please make sure the output type/dims are correct. Error: ${e}`
            );
          } finally {
            this.module.stackRestore(stack);
          }
        }
      };
      init = async (name, module, env3, gpuAdapter) => {
        const jsepInit = module.jsepInit;
        if (!jsepInit) {
          throw new Error("Failed to initialize JSEP. The WebAssembly module is not built with JSEP support.");
        }
        if (name === "webgpu") {
          const webGpuBackendImpl = (init_backend_webgpu(), __toCommonJS(backend_webgpu_exports)).WebGpuBackend;
          const backend = new webGpuBackendImpl();
          await backend.initialize(env3, gpuAdapter);
          jsepInit("webgpu", [
            // backend
            backend,
            // jsepAlloc()
            (size) => backend.alloc(Number(size)),
            // jsepFree()
            (ptr) => backend.free(ptr),
            // jsepCopy(src, dst, size, isSourceGpu)
            (src, dst, size, isSourceGpu = false) => {
              if (isSourceGpu) {
                LOG_DEBUG(
                  "verbose",
                  () => `[WebGPU] jsepCopyGpuToGpu: src=${Number(src)}, dst=${Number(dst)}, size=${Number(size)}`
                );
                backend.memcpy(Number(src), Number(dst));
              } else {
                LOG_DEBUG(
                  "verbose",
                  () => `[WebGPU] jsepCopyCpuToGpu: dataOffset=${Number(src)}, gpuDataId=${Number(dst)}, size=${Number(size)}`
                );
                const data = module.HEAPU8.subarray(Number(src >>> 0), Number(src >>> 0) + Number(size));
                backend.upload(Number(dst), data);
              }
            },
            // jsepCopyAsync(src, dst, size)
            async (gpuDataId, dataOffset, size) => {
              LOG_DEBUG(
                "verbose",
                () => `[WebGPU] jsepCopyGpuToCpu: gpuDataId=${gpuDataId}, dataOffset=${dataOffset}, size=${size}`
              );
              await backend.download(
                Number(gpuDataId),
                () => module.HEAPU8.subarray(Number(dataOffset) >>> 0, Number(dataOffset + size) >>> 0)
              );
            },
            // jsepCreateKernel
            (kernelType, kernelId, attribute) => backend.createKernel(
              kernelType,
              Number(kernelId),
              attribute,
              module.UTF8ToString(module._JsepGetNodeName(Number(kernelId)))
            ),
            // jsepReleaseKernel
            (kernel) => backend.releaseKernel(kernel),
            // jsepRun
            (kernel, contextDataOffset, sessionHandle, errors) => {
              LOG_DEBUG(
                "verbose",
                () => `[WebGPU] jsepRun: sessionHandle=${sessionHandle}, kernel=${kernel}, contextDataOffset=${contextDataOffset}`
              );
              const context = new ComputeContextImpl(module, backend, Number(contextDataOffset));
              return backend.computeKernel(Number(kernel), context, errors);
            },
            // jsepCaptureBegin
            () => backend.captureBegin(),
            // jsepCaptureEnd
            () => backend.captureEnd(),
            // jsepReplay
            () => backend.replay()
          ]);
        } else {
          const backend = new WebNNBackend(env3);
          jsepInit("webnn", [
            backend,
            // webnnReserveTensorId
            () => backend.reserveTensorId(),
            // webnnReleaseTensorId
            (tensorId) => backend.releaseTensorId(tensorId),
            // webnnEnsureTensor
            async (sessionId, tensorId, onnxDataType, shape, copyOld) => backend.ensureTensor(sessionId, tensorId, onnxDataType, shape, copyOld),
            // webnnUploadTensor
            (tensorId, data) => {
              backend.uploadTensor(tensorId, data);
            },
            // webnnDownloadTensor
            async (tensorId, dstBuffer) => backend.downloadTensor(tensorId, dstBuffer),
            // webnnRegisterMLContext
            (sessionId, mlContext) => backend.registerMLContext(sessionId, mlContext),
            // webnnEnableTraceEvent
            !!env3.trace
          ]);
        }
      };
    }
  });

  // web/lib/wasm/wasm-core-impl.ts
  var initOrt, initRuntime, initEp, activeSessions, getSessionInputOutputCount, getSessionInputOutputMetadata, copyFromExternalBuffer, createSession, releaseSession, prepareInputOutputTensor, run, endProfiling, extractTransferableBuffers;
  var init_wasm_core_impl = __esm({
    "web/lib/wasm/wasm-core-impl.ts"() {
      "use strict";
      init_esm();
      init_run_options();
      init_session_options();
      init_wasm_common();
      init_wasm_factory();
      init_wasm_utils();
      init_wasm_utils_load_file();
      initOrt = (numThreads, loggingLevel) => {
        const errorCode = getInstance()._OrtInit(numThreads, loggingLevel);
        if (errorCode !== 0) {
          checkLastError("Can't initialize onnxruntime.");
        }
      };
      initRuntime = async (env3) => {
        initOrt(env3.wasm.numThreads, logLevelStringToEnum(env3.logLevel));
      };
      initEp = async (env3, epName) => {
        getInstance().asyncInit?.();
        let webgpuAdapter = env3.webgpu.adapter;
        if (epName === "webgpu") {
          if (typeof navigator === "undefined" || !navigator.gpu) {
            throw new Error("WebGPU is not supported in current environment");
          }
          if (!webgpuAdapter) {
            const powerPreference = env3.webgpu.powerPreference;
            if (powerPreference !== void 0 && powerPreference !== "low-power" && powerPreference !== "high-performance") {
              throw new Error(`Invalid powerPreference setting: "${powerPreference}"`);
            }
            const forceFallbackAdapter = env3.webgpu.forceFallbackAdapter;
            if (forceFallbackAdapter !== void 0 && typeof forceFallbackAdapter !== "boolean") {
              throw new Error(`Invalid forceFallbackAdapter setting: "${forceFallbackAdapter}"`);
            }
            webgpuAdapter = await navigator.gpu.requestAdapter({ powerPreference, forceFallbackAdapter });
            if (!webgpuAdapter) {
              throw new Error(
                'Failed to get GPU adapter. You may need to enable flag "--enable-unsafe-webgpu" if you are using Chrome.'
              );
            }
          } else {
            if (typeof webgpuAdapter.limits !== "object" || typeof webgpuAdapter.features !== "object" || typeof webgpuAdapter.requestDevice !== "function") {
              throw new Error("Invalid GPU adapter set in `env.webgpu.adapter`. It must be a GPUAdapter object.");
            }
          }
        }
        if (epName === "webnn") {
          if (typeof navigator === "undefined" || !navigator.ml) {
            throw new Error("WebNN is not supported in current environment");
          }
        }
        if (true) {
          const initJsep = (init_init(), __toCommonJS(init_exports)).init;
          if (epName === "webgpu") {
            await initJsep("webgpu", getInstance(), env3, webgpuAdapter);
          }
          if (epName === "webnn") {
            await initJsep("webnn", getInstance(), env3);
          }
        } else {
          if (false) {
            getInstance().webgpuInit((device) => {
              env3.webgpu.device = device;
            });
          }
          if (epName === "webnn") {
            const backend = new null.WebNNBackend(env3);
            getInstance().webnnInit([
              backend,
              // webnnReserveTensorId
              () => backend.reserveTensorId(),
              // webnnReleaseTensorId,
              (tensorId) => backend.releaseTensorId(tensorId),
              // webnnEnsureTensor
              async (sessionId, tensorId, onnxDataType, shape, copyOld) => backend.ensureTensor(sessionId, tensorId, onnxDataType, shape, copyOld),
              // webnnUploadTensor
              (tensorId, data) => {
                backend.uploadTensor(tensorId, data);
              },
              // webnnDownloadTensor
              async (tensorId, dstBuffer) => backend.downloadTensor(tensorId, dstBuffer),
              // webnnRegisterMLContext
              (sessionId, mlContext) => backend.registerMLContext(sessionId, mlContext),
              // webnnEnableTraceEvent
              !!env3.trace
            ]);
          }
        }
      };
      activeSessions = /* @__PURE__ */ new Map();
      getSessionInputOutputCount = (sessionHandle) => {
        const wasm2 = getInstance();
        const stack = wasm2.stackSave();
        try {
          const ptrSize = wasm2.PTR_SIZE;
          const dataOffset = wasm2.stackAlloc(2 * ptrSize);
          const errorCode = wasm2._OrtGetInputOutputCount(sessionHandle, dataOffset, dataOffset + ptrSize);
          if (errorCode !== 0) {
            checkLastError("Can't get session input/output count.");
          }
          const type = ptrSize === 4 ? "i32" : "i64";
          return [Number(wasm2.getValue(dataOffset, type)), Number(wasm2.getValue(dataOffset + ptrSize, type))];
        } finally {
          wasm2.stackRestore(stack);
        }
      };
      getSessionInputOutputMetadata = (sessionHandle, index) => {
        const wasm2 = getInstance();
        const stack = wasm2.stackSave();
        let metadataOffset = 0;
        try {
          const ptrSize = wasm2.PTR_SIZE;
          const dataOffset = wasm2.stackAlloc(2 * ptrSize);
          const errorCode = wasm2._OrtGetInputOutputMetadata(sessionHandle, index, dataOffset, dataOffset + ptrSize);
          if (errorCode !== 0) {
            checkLastError("Can't get session input/output metadata.");
          }
          const nameOffset = Number(wasm2.getValue(dataOffset, "*"));
          metadataOffset = Number(wasm2.getValue(dataOffset + ptrSize, "*"));
          const elementType = wasm2.HEAP32[metadataOffset / 4];
          if (elementType === 0) {
            return [nameOffset, 0];
          }
          const dimsCount = wasm2.HEAPU32[metadataOffset / 4 + 1];
          const dims = [];
          for (let i = 0; i < dimsCount; i++) {
            const symbolicDimNameOffset = Number(wasm2.getValue(metadataOffset + 8 + i * ptrSize, "*"));
            dims.push(
              symbolicDimNameOffset !== 0 ? wasm2.UTF8ToString(symbolicDimNameOffset) : Number(wasm2.getValue(metadataOffset + 8 + (i + dimsCount) * ptrSize, "*"))
            );
          }
          return [nameOffset, elementType, dims];
        } finally {
          wasm2.stackRestore(stack);
          if (metadataOffset !== 0) {
            wasm2._OrtFree(metadataOffset);
          }
        }
      };
      copyFromExternalBuffer = (model) => {
        const wasm2 = getInstance();
        const modelDataOffset = wasm2._malloc(model.byteLength);
        if (modelDataOffset === 0) {
          throw new Error(`Can't create a session. failed to allocate a buffer of size ${model.byteLength}.`);
        }
        wasm2.HEAPU8.set(model, modelDataOffset);
        return [modelDataOffset, model.byteLength];
      };
      createSession = async (modelData, options) => {
        let modelDataOffset, modelDataLength;
        const wasm2 = getInstance();
        if (Array.isArray(modelData)) {
          [modelDataOffset, modelDataLength] = modelData;
        } else if (modelData.buffer === wasm2.HEAPU8.buffer) {
          [modelDataOffset, modelDataLength] = [modelData.byteOffset, modelData.byteLength];
        } else {
          [modelDataOffset, modelDataLength] = copyFromExternalBuffer(modelData);
        }
        let sessionHandle = 0;
        let sessionOptionsHandle = 0;
        let ioBindingHandle = 0;
        let allocs = [];
        const inputNamesUTF8Encoded = [];
        const outputNamesUTF8Encoded = [];
        try {
          [sessionOptionsHandle, allocs] = await setSessionOptions(options);
          if (options?.externalData && wasm2.mountExternalData) {
            const loadingPromises = [];
            for (const file of options.externalData) {
              const path = typeof file === "string" ? file : file.path;
              loadingPromises.push(
                loadFile(typeof file === "string" ? file : file.data).then((data) => {
                  wasm2.mountExternalData(path, data);
                })
              );
            }
            await Promise.all(loadingPromises);
          }
          for (const provider of options?.executionProviders ?? []) {
            const providerName = typeof provider === "string" ? provider : provider.name;
            if (providerName === "webnn") {
              wasm2.shouldTransferToMLTensor = false;
              if (typeof provider !== "string") {
                const webnnOptions = provider;
                const context = webnnOptions?.context;
                const gpuDevice = webnnOptions?.gpuDevice;
                const deviceType = webnnOptions?.deviceType;
                const powerPreference = webnnOptions?.powerPreference;
                if (context) {
                  wasm2.currentContext = context;
                } else if (gpuDevice) {
                  wasm2.currentContext = await wasm2.webnnCreateMLContext(gpuDevice);
                } else {
                  wasm2.currentContext = await wasm2.webnnCreateMLContext({ deviceType, powerPreference });
                }
              } else {
                wasm2.currentContext = await wasm2.webnnCreateMLContext();
              }
              break;
            }
          }
          sessionHandle = await wasm2._OrtCreateSession(modelDataOffset, modelDataLength, sessionOptionsHandle);
          wasm2.webgpuOnCreateSession?.(sessionHandle);
          if (sessionHandle === 0) {
            checkLastError("Can't create a session.");
          }
          wasm2.jsepOnCreateSession?.();
          if (wasm2.currentContext) {
            wasm2.webnnRegisterMLContext(sessionHandle, wasm2.currentContext);
            wasm2.currentContext = void 0;
            wasm2.shouldTransferToMLTensor = true;
          }
          const [inputCount, outputCount] = getSessionInputOutputCount(sessionHandle);
          const enableGraphCapture = !!options?.enableGraphCapture;
          const inputNames = [];
          const outputNames = [];
          const inputMetadata = [];
          const outputMetadata = [];
          const outputPreferredLocations = [];
          for (let i = 0; i < inputCount; i++) {
            const [nameOffset, elementType, shape] = getSessionInputOutputMetadata(sessionHandle, i);
            if (nameOffset === 0) {
              checkLastError("Can't get an input name.");
            }
            inputNamesUTF8Encoded.push(nameOffset);
            const name = wasm2.UTF8ToString(nameOffset);
            inputNames.push(name);
            inputMetadata.push(
              elementType === 0 ? { name, isTensor: false } : { name, isTensor: true, type: tensorDataTypeEnumToString(elementType), shape }
            );
          }
          for (let i = 0; i < outputCount; i++) {
            const [nameOffset, elementType, shape] = getSessionInputOutputMetadata(sessionHandle, i + inputCount);
            if (nameOffset === 0) {
              checkLastError("Can't get an output name.");
            }
            outputNamesUTF8Encoded.push(nameOffset);
            const nameString = wasm2.UTF8ToString(nameOffset);
            outputNames.push(nameString);
            outputMetadata.push(
              elementType === 0 ? { name: nameString, isTensor: false } : { name: nameString, isTensor: true, type: tensorDataTypeEnumToString(elementType), shape }
            );
            if (true) {
              if (enableGraphCapture && options?.preferredOutputLocation === void 0) {
                outputPreferredLocations.push("gpu-buffer");
                continue;
              }
              const location2 = typeof options?.preferredOutputLocation === "string" ? options.preferredOutputLocation : options?.preferredOutputLocation?.[nameString] ?? "cpu";
              const isGraphOutput = wasm2.webnnIsGraphOutput;
              if (location2 === "cpu" && isGraphOutput && isGraphOutput(sessionHandle, nameString)) {
                outputPreferredLocations.push("ml-tensor-cpu-output");
                continue;
              }
              if (location2 !== "cpu" && location2 !== "cpu-pinned" && location2 !== "gpu-buffer" && location2 !== "ml-tensor") {
                throw new Error(`Not supported preferred output location: ${location2}.`);
              }
              if (enableGraphCapture && location2 !== "gpu-buffer") {
                throw new Error(
                  `Not supported preferred output location: ${location2}. Only 'gpu-buffer' location is supported when enableGraphCapture is true.`
                );
              }
              outputPreferredLocations.push(location2);
            }
          }
          let bindingState = null;
          if (outputPreferredLocations.some((l) => l === "gpu-buffer" || l === "ml-tensor" || l === "ml-tensor-cpu-output")) {
            ioBindingHandle = wasm2._OrtCreateBinding(sessionHandle);
            if (ioBindingHandle === 0) {
              checkLastError("Can't create IO binding.");
            }
            bindingState = {
              handle: ioBindingHandle,
              outputPreferredLocations,
              outputPreferredLocationsEncoded: outputPreferredLocations.map((l) => l === "ml-tensor-cpu-output" ? "ml-tensor" : l).map((l) => dataLocationStringToEnum(l))
            };
          }
          activeSessions.set(sessionHandle, [
            sessionHandle,
            inputNamesUTF8Encoded,
            outputNamesUTF8Encoded,
            bindingState,
            enableGraphCapture,
            false
          ]);
          return [sessionHandle, inputNames, outputNames, inputMetadata, outputMetadata];
        } catch (e) {
          inputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));
          outputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));
          if (ioBindingHandle !== 0) {
            if (wasm2._OrtReleaseBinding(ioBindingHandle) !== 0) {
              checkLastError("Can't release IO binding.");
            }
          }
          if (sessionHandle !== 0) {
            if (wasm2._OrtReleaseSession(sessionHandle) !== 0) {
              checkLastError("Can't release session.");
            }
          }
          throw e;
        } finally {
          wasm2._free(modelDataOffset);
          if (sessionOptionsHandle !== 0) {
            if (wasm2._OrtReleaseSessionOptions(sessionOptionsHandle) !== 0) {
              checkLastError("Can't release session options.");
            }
          }
          allocs.forEach((alloc) => wasm2._free(alloc));
          wasm2.unmountExternalData?.();
        }
      };
      releaseSession = (sessionId) => {
        const wasm2 = getInstance();
        const session = activeSessions.get(sessionId);
        if (!session) {
          throw new Error(`cannot release session. invalid session id: ${sessionId}`);
        }
        const [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture] = session;
        if (ioBindingState) {
          if (enableGraphCapture) {
            if (wasm2._OrtClearBoundOutputs(ioBindingState.handle) !== 0) {
              checkLastError("Can't clear bound outputs.");
            }
          }
          if (wasm2._OrtReleaseBinding(ioBindingState.handle) !== 0) {
            checkLastError("Can't release IO binding.");
          }
        }
        wasm2.jsepOnReleaseSession?.(sessionId);
        wasm2.webnnOnReleaseSession?.(sessionId);
        wasm2.webgpuOnReleaseSession?.(sessionId);
        inputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));
        outputNamesUTF8Encoded.forEach((buf) => wasm2._OrtFree(buf));
        if (wasm2._OrtReleaseSession(sessionHandle) !== 0) {
          checkLastError("Can't release session.");
        }
        activeSessions.delete(sessionId);
      };
      prepareInputOutputTensor = async (tensor, tensorHandles, allocs, sessionId, tensorNameUTF8Encoded, index, enableGraphCapture = false) => {
        if (!tensor) {
          tensorHandles.push(0);
          return;
        }
        const wasm2 = getInstance();
        const ptrSize = wasm2.PTR_SIZE;
        const dataType = tensor[0];
        const dims = tensor[1];
        const location2 = tensor[3];
        let actualLocation = location2;
        let rawData;
        let dataByteLength;
        if (dataType === "string" && (location2 === "gpu-buffer" || location2 === "ml-tensor")) {
          throw new Error("String tensor is not supported on GPU.");
        }
        if (enableGraphCapture && location2 !== "gpu-buffer") {
          throw new Error(
            `External buffer must be provided for input/output index ${index} when enableGraphCapture is true.`
          );
        }
        if (location2 === "gpu-buffer") {
          const gpuBuffer = tensor[2].gpuBuffer;
          dataByteLength = calculateTensorSizeInBytes(tensorDataTypeStringToEnum(dataType), dims);
          if (false) {
            const registerBuffer = wasm2.webgpuRegisterBuffer;
            if (!registerBuffer) {
              throw new Error('Tensor location "gpu-buffer" is not supported without using WebGPU.');
            }
            rawData = registerBuffer(gpuBuffer, sessionId);
          } else {
            const registerBuffer = wasm2.jsepRegisterBuffer;
            if (!registerBuffer) {
              throw new Error('Tensor location "gpu-buffer" is not supported without using WebGPU.');
            }
            rawData = registerBuffer(sessionId, index, gpuBuffer, dataByteLength);
          }
        } else if (location2 === "ml-tensor") {
          const mlTensor = tensor[2].mlTensor;
          dataByteLength = calculateTensorSizeInBytes(tensorDataTypeStringToEnum(dataType), dims);
          const registerMLTensor = wasm2.webnnRegisterMLTensor;
          if (!registerMLTensor) {
            throw new Error('Tensor location "ml-tensor" is not supported without using WebNN.');
          }
          rawData = registerMLTensor(sessionId, mlTensor, tensorDataTypeStringToEnum(dataType), dims);
        } else {
          const data = tensor[2];
          if (Array.isArray(data)) {
            dataByteLength = ptrSize * data.length;
            rawData = wasm2._malloc(dataByteLength);
            allocs.push(rawData);
            for (let i = 0; i < data.length; i++) {
              if (typeof data[i] !== "string") {
                throw new TypeError(`tensor data at index ${i} is not a string`);
              }
              wasm2.setValue(rawData + i * ptrSize, allocWasmString(data[i], allocs), "*");
            }
          } else {
            const isGraphInput = wasm2.webnnIsGraphInput;
            const isGraphOutput = wasm2.webnnIsGraphOutput;
            if (dataType !== "string" && isGraphInput && isGraphOutput) {
              const tensorName = wasm2.UTF8ToString(tensorNameUTF8Encoded);
              if (isGraphInput(sessionId, tensorName) || isGraphOutput(sessionId, tensorName)) {
                const dataTypeEnum = tensorDataTypeStringToEnum(dataType);
                dataByteLength = calculateTensorSizeInBytes(dataTypeEnum, dims);
                actualLocation = "ml-tensor";
                const createTemporaryTensor = wasm2.webnnCreateTemporaryTensor;
                const uploadTensor = wasm2.webnnUploadTensor;
                if (!createTemporaryTensor || !uploadTensor) {
                  throw new Error('Tensor location "ml-tensor" is not supported without using WebNN.');
                }
                const tensorId = await createTemporaryTensor(sessionId, dataTypeEnum, dims);
                uploadTensor(tensorId, new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
                rawData = tensorId;
              } else {
                dataByteLength = data.byteLength;
                rawData = wasm2._malloc(dataByteLength);
                allocs.push(rawData);
                wasm2.HEAPU8.set(new Uint8Array(data.buffer, data.byteOffset, dataByteLength), rawData);
              }
            } else {
              dataByteLength = data.byteLength;
              rawData = wasm2._malloc(dataByteLength);
              allocs.push(rawData);
              wasm2.HEAPU8.set(new Uint8Array(data.buffer, data.byteOffset, dataByteLength), rawData);
            }
          }
        }
        const stack = wasm2.stackSave();
        const dimsOffset = wasm2.stackAlloc(4 * dims.length);
        try {
          dims.forEach((d, index2) => wasm2.setValue(dimsOffset + index2 * ptrSize, d, ptrSize === 4 ? "i32" : "i64"));
          const tensor2 = wasm2._OrtCreateTensor(
            tensorDataTypeStringToEnum(dataType),
            rawData,
            dataByteLength,
            dimsOffset,
            dims.length,
            dataLocationStringToEnum(actualLocation)
          );
          if (tensor2 === 0) {
            checkLastError(`Can't create tensor for input/output. session=${sessionId}, index=${index}.`);
          }
          tensorHandles.push(tensor2);
        } finally {
          wasm2.stackRestore(stack);
        }
      };
      run = async (sessionId, inputIndices, inputTensors, outputIndices, outputTensors, options) => {
        const wasm2 = getInstance();
        const ptrSize = wasm2.PTR_SIZE;
        const session = activeSessions.get(sessionId);
        if (!session) {
          throw new Error(`cannot run inference. invalid session id: ${sessionId}`);
        }
        const sessionHandle = session[0];
        const inputNamesUTF8Encoded = session[1];
        const outputNamesUTF8Encoded = session[2];
        const ioBindingState = session[3];
        const enableGraphCapture = session[4];
        const inputOutputBound = session[5];
        const inputCount = inputIndices.length;
        const outputCount = outputIndices.length;
        let runOptionsHandle = 0;
        let runOptionsAllocs = [];
        const inputTensorHandles = [];
        const outputTensorHandles = [];
        const inputOutputAllocs = [];
        const preAllocatedOutputs = [];
        const beforeRunStack = wasm2.stackSave();
        const inputValuesOffset = wasm2.stackAlloc(inputCount * ptrSize);
        const inputNamesOffset = wasm2.stackAlloc(inputCount * ptrSize);
        const outputValuesOffset = wasm2.stackAlloc(outputCount * ptrSize);
        const outputNamesOffset = wasm2.stackAlloc(outputCount * ptrSize);
        try {
          [runOptionsHandle, runOptionsAllocs] = setRunOptions(options);
          TRACE_EVENT_BEGIN("wasm prepareInputOutputTensor");
          for (let i = 0; i < inputCount; i++) {
            await prepareInputOutputTensor(
              inputTensors[i],
              inputTensorHandles,
              inputOutputAllocs,
              sessionId,
              inputNamesUTF8Encoded[inputIndices[i]],
              inputIndices[i],
              enableGraphCapture
            );
          }
          for (let i = 0; i < outputCount; i++) {
            await prepareInputOutputTensor(
              outputTensors[i],
              outputTensorHandles,
              inputOutputAllocs,
              sessionId,
              outputNamesUTF8Encoded[outputIndices[i]],
              inputCount + outputIndices[i],
              enableGraphCapture
            );
          }
          TRACE_EVENT_END("wasm prepareInputOutputTensor");
          for (let i = 0; i < inputCount; i++) {
            wasm2.setValue(inputValuesOffset + i * ptrSize, inputTensorHandles[i], "*");
            wasm2.setValue(inputNamesOffset + i * ptrSize, inputNamesUTF8Encoded[inputIndices[i]], "*");
          }
          for (let i = 0; i < outputCount; i++) {
            wasm2.setValue(outputValuesOffset + i * ptrSize, outputTensorHandles[i], "*");
            wasm2.setValue(outputNamesOffset + i * ptrSize, outputNamesUTF8Encoded[outputIndices[i]], "*");
          }
          if (ioBindingState && !inputOutputBound) {
            const { handle, outputPreferredLocations, outputPreferredLocationsEncoded } = ioBindingState;
            if (inputNamesUTF8Encoded.length !== inputCount) {
              throw new Error(
                `input count from feeds (${inputCount}) is expected to be always equal to model's input count (${inputNamesUTF8Encoded.length}).`
              );
            }
            TRACE_EVENT_BEGIN("wasm bindInputsOutputs");
            for (let i = 0; i < inputCount; i++) {
              const index = inputIndices[i];
              const errorCode2 = await wasm2._OrtBindInput(handle, inputNamesUTF8Encoded[index], inputTensorHandles[i]);
              if (errorCode2 !== 0) {
                checkLastError(`Can't bind input[${i}] for session=${sessionId}.`);
              }
            }
            for (let i = 0; i < outputCount; i++) {
              const index = outputIndices[i];
              const location2 = outputTensors[i]?.[3];
              if (location2) {
                preAllocatedOutputs.push(outputTensorHandles[i]);
                const errorCode2 = wasm2._OrtBindOutput(handle, outputNamesUTF8Encoded[index], outputTensorHandles[i], 0);
                if (errorCode2 !== 0) {
                  checkLastError(`Can't bind pre-allocated output[${i}] for session=${sessionId}.`);
                }
              } else {
                const errorCode2 = wasm2._OrtBindOutput(
                  handle,
                  outputNamesUTF8Encoded[index],
                  0,
                  outputPreferredLocationsEncoded[index]
                );
                if (errorCode2 !== 0) {
                  checkLastError(`Can't bind output[${i}] to ${outputPreferredLocations[i]} for session=${sessionId}.`);
                }
              }
            }
            TRACE_EVENT_END("wasm bindInputsOutputs");
            activeSessions.set(sessionId, [
              sessionHandle,
              inputNamesUTF8Encoded,
              outputNamesUTF8Encoded,
              ioBindingState,
              enableGraphCapture,
              true
            ]);
          }
          wasm2.jsepOnRunStart?.(sessionHandle);
          wasm2.webnnOnRunStart?.(sessionHandle);
          let errorCode;
          if (ioBindingState) {
            errorCode = await wasm2._OrtRunWithBinding(
              sessionHandle,
              ioBindingState.handle,
              outputCount,
              outputValuesOffset,
              runOptionsHandle
            );
          } else {
            errorCode = await wasm2._OrtRun(
              sessionHandle,
              inputNamesOffset,
              inputValuesOffset,
              inputCount,
              outputNamesOffset,
              outputCount,
              outputValuesOffset,
              runOptionsHandle
            );
          }
          if (errorCode !== 0) {
            checkLastError("failed to call OrtRun().");
          }
          const output = [];
          const outputPromises = [];
          TRACE_EVENT_BEGIN("wasm ProcessOutputTensor");
          for (let i = 0; i < outputCount; i++) {
            const tensor = Number(wasm2.getValue(outputValuesOffset + i * ptrSize, "*"));
            if (tensor === outputTensorHandles[i] || preAllocatedOutputs.includes(outputTensorHandles[i])) {
              output.push(outputTensors[i]);
              if (tensor !== outputTensorHandles[i]) {
                if (wasm2._OrtReleaseTensor(tensor) !== 0) {
                  checkLastError("Can't release tensor.");
                }
              }
              continue;
            }
            const beforeGetTensorDataStack = wasm2.stackSave();
            const tensorDataOffset = wasm2.stackAlloc(4 * ptrSize);
            let keepOutputTensor = false;
            let type, dataOffset = 0;
            try {
              const errorCode2 = wasm2._OrtGetTensorData(
                tensor,
                tensorDataOffset,
                tensorDataOffset + ptrSize,
                tensorDataOffset + 2 * ptrSize,
                tensorDataOffset + 3 * ptrSize
              );
              if (errorCode2 !== 0) {
                checkLastError(`Can't access output tensor data on index ${i}.`);
              }
              const valueType = ptrSize === 4 ? "i32" : "i64";
              const dataType = Number(wasm2.getValue(tensorDataOffset, valueType));
              dataOffset = wasm2.getValue(tensorDataOffset + ptrSize, "*");
              const dimsOffset = wasm2.getValue(tensorDataOffset + ptrSize * 2, "*");
              const dimsLength = Number(wasm2.getValue(tensorDataOffset + ptrSize * 3, valueType));
              const dims = [];
              for (let i2 = 0; i2 < dimsLength; i2++) {
                dims.push(Number(wasm2.getValue(dimsOffset + i2 * ptrSize, valueType)));
              }
              if (wasm2._OrtFree(dimsOffset) !== 0) {
                checkLastError("Can't free memory for tensor dims.");
              }
              const size = dims.reduce((a, b) => a * b, 1);
              type = tensorDataTypeEnumToString(dataType);
              const preferredLocation = ioBindingState?.outputPreferredLocations[outputIndices[i]];
              if (type === "string") {
                if (preferredLocation === "gpu-buffer" || preferredLocation === "ml-tensor") {
                  throw new Error("String tensor is not supported on GPU.");
                }
                const stringData = [];
                for (let i2 = 0; i2 < size; i2++) {
                  const offset = wasm2.getValue(dataOffset + i2 * ptrSize, "*");
                  const nextOffset = wasm2.getValue(dataOffset + (i2 + 1) * ptrSize, "*");
                  const maxBytesToRead = i2 === size - 1 ? void 0 : nextOffset - offset;
                  stringData.push(wasm2.UTF8ToString(offset, maxBytesToRead));
                }
                output.push([type, dims, stringData, "cpu"]);
              } else {
                if (preferredLocation === "gpu-buffer" && size > 0) {
                  const getBuffer = false ? wasm2.webgpuGetBuffer : wasm2.jsepGetBuffer;
                  if (!getBuffer) {
                    throw new Error('preferredLocation "gpu-buffer" is not supported without using WebGPU.');
                  }
                  const gpuBuffer = getBuffer(dataOffset);
                  const bufferSize = calculateTensorSizeInBytes(dataType, size);
                  if (bufferSize === void 0 || !isGpuBufferSupportedType(type)) {
                    throw new Error(`Unsupported data type: ${type}`);
                  }
                  keepOutputTensor = true;
                  if (false) {
                    wasm2.webgpuRegisterBuffer(gpuBuffer, sessionId, dataOffset);
                    const downloadDataFunction = wasm2.webgpuCreateDownloader(gpuBuffer, bufferSize, sessionId);
                    output.push([
                      type,
                      dims,
                      {
                        gpuBuffer,
                        download: async () => {
                          const arrayBuffer = await downloadDataFunction();
                          const data = new (tensorTypeToTypedArrayConstructor(type))(arrayBuffer);
                          return data;
                        },
                        dispose: () => {
                          if (wasm2._OrtReleaseTensor(tensor) !== 0) {
                            checkLastError("Can't release tensor.");
                          }
                        }
                      },
                      "gpu-buffer"
                    ]);
                  } else {
                    output.push([
                      type,
                      dims,
                      {
                        gpuBuffer,
                        download: wasm2.jsepCreateDownloader(gpuBuffer, bufferSize, type),
                        dispose: () => {
                          if (wasm2._OrtReleaseTensor(tensor) !== 0) {
                            checkLastError("Can't release tensor.");
                          }
                        }
                      },
                      "gpu-buffer"
                    ]);
                  }
                } else if (preferredLocation === "ml-tensor" && size > 0) {
                  const ensureTensor = wasm2.webnnEnsureTensor;
                  const isGraphInputOutputTypeSupported = wasm2.webnnIsGraphInputOutputTypeSupported;
                  if (!ensureTensor || !isGraphInputOutputTypeSupported) {
                    throw new Error('preferredLocation "ml-tensor" is not supported without using WebNN.');
                  }
                  const tensorSize = calculateTensorSizeInBytes(dataType, size);
                  if (tensorSize === void 0 || !isMLTensorSupportedType(type)) {
                    throw new Error(`Unsupported data type: ${type}`);
                  }
                  if (!isGraphInputOutputTypeSupported(sessionId, type, false)) {
                    throw new Error(
                      `preferredLocation "ml-tensor" for ${type} output is not supported by current WebNN Context.`
                    );
                  }
                  const mlTensor = await ensureTensor(sessionId, dataOffset, dataType, dims, false);
                  keepOutputTensor = true;
                  output.push([
                    type,
                    dims,
                    {
                      mlTensor,
                      download: wasm2.webnnCreateMLTensorDownloader(dataOffset, type),
                      dispose: () => {
                        wasm2.webnnReleaseTensorId(dataOffset);
                        wasm2._OrtReleaseTensor(tensor);
                      }
                    },
                    "ml-tensor"
                  ]);
                } else if (preferredLocation === "ml-tensor-cpu-output" && size > 0) {
                  const data = wasm2.webnnCreateMLTensorDownloader(dataOffset, type)();
                  const index = output.length;
                  keepOutputTensor = true;
                  outputPromises.push(
                    (async () => {
                      const result = [index, await data];
                      wasm2.webnnReleaseTensorId(dataOffset);
                      wasm2._OrtReleaseTensor(tensor);
                      return result;
                    })()
                  );
                  output.push([type, dims, [], "cpu"]);
                } else {
                  const typedArrayConstructor = tensorTypeToTypedArrayConstructor(type);
                  const data = new typedArrayConstructor(size);
                  new Uint8Array(data.buffer, data.byteOffset, data.byteLength).set(
                    wasm2.HEAPU8.subarray(dataOffset, dataOffset + data.byteLength)
                  );
                  output.push([type, dims, data, "cpu"]);
                }
              }
            } finally {
              wasm2.stackRestore(beforeGetTensorDataStack);
              if (type === "string" && dataOffset) {
                wasm2._free(dataOffset);
              }
              if (!keepOutputTensor) {
                wasm2._OrtReleaseTensor(tensor);
              }
            }
          }
          if (ioBindingState && !enableGraphCapture) {
            if (wasm2._OrtClearBoundOutputs(ioBindingState.handle) !== 0) {
              checkLastError("Can't clear bound outputs.");
            }
            activeSessions.set(sessionId, [
              sessionHandle,
              inputNamesUTF8Encoded,
              outputNamesUTF8Encoded,
              ioBindingState,
              enableGraphCapture,
              false
            ]);
          }
          for (const [index, data] of await Promise.all(outputPromises)) {
            output[index][2] = data;
          }
          TRACE_EVENT_END("wasm ProcessOutputTensor");
          return output;
        } finally {
          wasm2.webnnOnRunEnd?.(sessionHandle);
          wasm2.stackRestore(beforeRunStack);
          if (false) {
            inputTensors.forEach((t) => {
              if (t && t[3] === "gpu-buffer") {
                wasm2.webgpuUnregisterBuffer(t[2].gpuBuffer);
              }
            });
            outputTensors.forEach((t) => {
              if (t && t[3] === "gpu-buffer") {
                wasm2.webgpuUnregisterBuffer(t[2].gpuBuffer);
              }
            });
          }
          inputTensorHandles.forEach((v) => wasm2._OrtReleaseTensor(v));
          outputTensorHandles.forEach((v) => wasm2._OrtReleaseTensor(v));
          inputOutputAllocs.forEach((p) => wasm2._free(p));
          if (runOptionsHandle !== 0) {
            wasm2._OrtReleaseRunOptions(runOptionsHandle);
          }
          runOptionsAllocs.forEach((p) => wasm2._free(p));
        }
      };
      endProfiling = (sessionId) => {
        const wasm2 = getInstance();
        const session = activeSessions.get(sessionId);
        if (!session) {
          throw new Error("invalid session id");
        }
        const sessionHandle = session[0];
        const profileFileName = wasm2._OrtEndProfiling(sessionHandle);
        if (profileFileName === 0) {
          checkLastError("Can't get an profile file name.");
        }
        wasm2._OrtFree(profileFileName);
      };
      extractTransferableBuffers = (tensors) => {
        const buffers = [];
        for (const tensor of tensors) {
          const data = tensor[2];
          if (!Array.isArray(data) && "buffer" in data) {
            buffers.push(data.buffer);
          }
        }
        return buffers;
      };
    }
  });

  // web/lib/wasm/proxy-wrapper.ts
  var isProxy, proxyWorker, initializing2, initialized2, aborted2, temporaryObjectUrl, initWasmCallbacks, queuedCallbacks, enqueueCallbacks, ensureWorker, onProxyWorkerMessage, initializeWebAssemblyAndOrtRuntime, initializeOrtEp, copyFromExternalBuffer2, createSession2, releaseSession2, run2, endProfiling2;
  var init_proxy_wrapper = __esm({
    "web/lib/wasm/proxy-wrapper.ts"() {
      "use strict";
      init_esm();
      init_wasm_core_impl();
      init_wasm_factory();
      init_wasm_utils_import();
      isProxy = () => !!env2.wasm.proxy && typeof document !== "undefined";
      initializing2 = false;
      initialized2 = false;
      aborted2 = false;
      queuedCallbacks = /* @__PURE__ */ new Map();
      enqueueCallbacks = (type, callbacks) => {
        const queue = queuedCallbacks.get(type);
        if (queue) {
          queue.push(callbacks);
        } else {
          queuedCallbacks.set(type, [callbacks]);
        }
      };
      ensureWorker = () => {
        if (initializing2 || !initialized2 || aborted2 || !proxyWorker) {
          throw new Error("worker not ready");
        }
      };
      onProxyWorkerMessage = (ev) => {
        switch (ev.data.type) {
          case "init-wasm":
            initializing2 = false;
            if (ev.data.err) {
              aborted2 = true;
              initWasmCallbacks[1](ev.data.err);
            } else {
              initialized2 = true;
              initWasmCallbacks[0]();
            }
            if (temporaryObjectUrl) {
              URL.revokeObjectURL(temporaryObjectUrl);
              temporaryObjectUrl = void 0;
            }
            break;
          case "init-ep":
          case "copy-from":
          case "create":
          case "release":
          case "run":
          case "end-profiling": {
            const callbacks = queuedCallbacks.get(ev.data.type);
            if (ev.data.err) {
              callbacks.shift()[1](ev.data.err);
            } else {
              callbacks.shift()[0](ev.data.out);
            }
            break;
          }
          default:
        }
      };
      initializeWebAssemblyAndOrtRuntime = async () => {
        if (initialized2) {
          return;
        }
        if (initializing2) {
          throw new Error("multiple calls to 'initWasm()' detected.");
        }
        if (aborted2) {
          throw new Error("previous call to 'initWasm()' failed.");
        }
        initializing2 = true;
        if (isProxy()) {
          return new Promise((resolve, reject) => {
            proxyWorker?.terminate();
            void importProxyWorker().then(([objectUrl, worker]) => {
              try {
                proxyWorker = worker;
                proxyWorker.onerror = (ev) => reject(ev);
                proxyWorker.onmessage = onProxyWorkerMessage;
                initWasmCallbacks = [resolve, reject];
                const message = { type: "init-wasm", in: env2 };
                if (!message.in.wasm.wasmPaths && objectUrl) {
                  const inferredWasmPathPrefix = inferWasmPathPrefixFromScriptSrc();
                  if (inferredWasmPathPrefix) {
                    message.in.wasm.wasmPaths = inferredWasmPathPrefix;
                  }
                }
                if (false) {
                  message.in.wasm.wasmPaths = {
                    wasm: true ? new URL("ort-wasm-simd-threaded.jsep.wasm", void 0).href : false ? new URL("ort-wasm-simd-threaded.jspi.wasm", void 0).href : false ? new URL("ort-wasm-simd-threaded.asyncify.wasm", void 0).href : new URL("ort-wasm-simd-threaded.wasm", void 0).href
                  };
                }
                proxyWorker.postMessage(message);
                temporaryObjectUrl = objectUrl;
              } catch (e) {
                reject(e);
              }
            }, reject);
          });
        } else {
          try {
            await initializeWebAssembly(env2.wasm);
            await initRuntime(env2);
            initialized2 = true;
          } catch (e) {
            aborted2 = true;
            throw e;
          } finally {
            initializing2 = false;
          }
        }
      };
      initializeOrtEp = async (epName) => {
        if (isProxy()) {
          ensureWorker();
          return new Promise((resolve, reject) => {
            enqueueCallbacks("init-ep", [resolve, reject]);
            const message = { type: "init-ep", in: { epName, env: env2 } };
            proxyWorker.postMessage(message);
          });
        } else {
          await initEp(env2, epName);
        }
      };
      copyFromExternalBuffer2 = async (buffer) => {
        if (isProxy()) {
          ensureWorker();
          return new Promise((resolve, reject) => {
            enqueueCallbacks("copy-from", [resolve, reject]);
            const message = { type: "copy-from", in: { buffer } };
            proxyWorker.postMessage(message, [buffer.buffer]);
          });
        } else {
          return copyFromExternalBuffer(buffer);
        }
      };
      createSession2 = async (model, options) => {
        if (isProxy()) {
          if (options?.preferredOutputLocation) {
            throw new Error('session option "preferredOutputLocation" is not supported for proxy.');
          }
          ensureWorker();
          return new Promise((resolve, reject) => {
            enqueueCallbacks("create", [resolve, reject]);
            const message = { type: "create", in: { model, options: { ...options } } };
            const transferable = [];
            if (model instanceof Uint8Array) {
              transferable.push(model.buffer);
            }
            proxyWorker.postMessage(message, transferable);
          });
        } else {
          return createSession(model, options);
        }
      };
      releaseSession2 = async (sessionId) => {
        if (isProxy()) {
          ensureWorker();
          return new Promise((resolve, reject) => {
            enqueueCallbacks("release", [resolve, reject]);
            const message = { type: "release", in: sessionId };
            proxyWorker.postMessage(message);
          });
        } else {
          releaseSession(sessionId);
        }
      };
      run2 = async (sessionId, inputIndices, inputs, outputIndices, outputs, options) => {
        if (isProxy()) {
          if (inputs.some((t) => t[3] !== "cpu")) {
            throw new Error("input tensor on GPU is not supported for proxy.");
          }
          if (outputs.some((t) => t)) {
            throw new Error("pre-allocated output tensor is not supported for proxy.");
          }
          ensureWorker();
          return new Promise((resolve, reject) => {
            enqueueCallbacks("run", [resolve, reject]);
            const serializableInputs = inputs;
            const message = {
              type: "run",
              in: { sessionId, inputIndices, inputs: serializableInputs, outputIndices, options }
            };
            proxyWorker.postMessage(message, extractTransferableBuffers(serializableInputs));
          });
        } else {
          return run(sessionId, inputIndices, inputs, outputIndices, outputs, options);
        }
      };
      endProfiling2 = async (sessionId) => {
        if (isProxy()) {
          ensureWorker();
          return new Promise((resolve, reject) => {
            enqueueCallbacks("end-profiling", [resolve, reject]);
            const message = { type: "end-profiling", in: sessionId };
            proxyWorker.postMessage(message);
          });
        } else {
          endProfiling(sessionId);
        }
      };
    }
  });

  // web/lib/wasm/session-handler-inference.ts
  var encodeTensorMetadata, decodeTensorMetadata, OnnxruntimeWebAssemblySessionHandler;
  var init_session_handler_inference = __esm({
    "web/lib/wasm/session-handler-inference.ts"() {
      "use strict";
      init_esm();
      init_proxy_wrapper();
      init_wasm_common();
      init_wasm_utils_env();
      init_wasm_utils_load_file();
      encodeTensorMetadata = (tensor, getName) => {
        switch (tensor.location) {
          case "cpu":
            return [tensor.type, tensor.dims, tensor.data, "cpu"];
          case "gpu-buffer":
            return [tensor.type, tensor.dims, { gpuBuffer: tensor.gpuBuffer }, "gpu-buffer"];
          case "ml-tensor":
            return [tensor.type, tensor.dims, { mlTensor: tensor.mlTensor }, "ml-tensor"];
          default:
            throw new Error(`invalid data location: ${tensor.location} for ${getName()}`);
        }
      };
      decodeTensorMetadata = (tensor) => {
        switch (tensor[3]) {
          case "cpu":
            return new Tensor2(tensor[0], tensor[2], tensor[1]);
          case "gpu-buffer": {
            const dataType = tensor[0];
            if (!isGpuBufferSupportedType(dataType)) {
              throw new Error(`not supported data type: ${dataType} for deserializing GPU tensor`);
            }
            const { gpuBuffer, download, dispose } = tensor[2];
            return Tensor2.fromGpuBuffer(gpuBuffer, { dataType, dims: tensor[1], download, dispose });
          }
          case "ml-tensor": {
            const dataType = tensor[0];
            if (!isMLTensorSupportedType(dataType)) {
              throw new Error(`not supported data type: ${dataType} for deserializing MLTensor tensor`);
            }
            const { mlTensor, download, dispose } = tensor[2];
            return Tensor2.fromMLTensor(mlTensor, { dataType, dims: tensor[1], download, dispose });
          }
          default:
            throw new Error(`invalid data location: ${tensor[3]}`);
        }
      };
      OnnxruntimeWebAssemblySessionHandler = class {
        async fetchModelAndCopyToWasmMemory(path) {
          return copyFromExternalBuffer2(await loadFile(path));
        }
        async loadModel(pathOrBuffer, options) {
          TRACE_FUNC_BEGIN();
          let model;
          if (typeof pathOrBuffer === "string") {
            if (isNode) {
              model = await loadFile(pathOrBuffer);
            } else {
              model = await this.fetchModelAndCopyToWasmMemory(pathOrBuffer);
            }
          } else {
            model = pathOrBuffer;
          }
          [this.sessionId, this.inputNames, this.outputNames, this.inputMetadata, this.outputMetadata] = await createSession2(
            model,
            options
          );
          TRACE_FUNC_END();
        }
        async dispose() {
          return releaseSession2(this.sessionId);
        }
        async run(feeds, fetches, options) {
          TRACE_FUNC_BEGIN();
          const inputArray = [];
          const inputIndices = [];
          Object.entries(feeds).forEach((kvp) => {
            const name = kvp[0];
            const tensor = kvp[1];
            const index = this.inputNames.indexOf(name);
            if (index === -1) {
              throw new Error(`invalid input '${name}'`);
            }
            inputArray.push(tensor);
            inputIndices.push(index);
          });
          const outputArray = [];
          const outputIndices = [];
          Object.entries(fetches).forEach((kvp) => {
            const name = kvp[0];
            const tensor = kvp[1];
            const index = this.outputNames.indexOf(name);
            if (index === -1) {
              throw new Error(`invalid output '${name}'`);
            }
            outputArray.push(tensor);
            outputIndices.push(index);
          });
          const inputs = inputArray.map(
            (t, i) => encodeTensorMetadata(t, () => `input "${this.inputNames[inputIndices[i]]}"`)
          );
          const outputs = outputArray.map(
            (t, i) => t ? encodeTensorMetadata(t, () => `output "${this.outputNames[outputIndices[i]]}"`) : null
          );
          const results = await run2(this.sessionId, inputIndices, inputs, outputIndices, outputs, options);
          const resultMap = {};
          for (let i = 0; i < results.length; i++) {
            resultMap[this.outputNames[outputIndices[i]]] = outputArray[i] ?? decodeTensorMetadata(results[i]);
          }
          TRACE_FUNC_END();
          return resultMap;
        }
        startProfiling() {
        }
        endProfiling() {
          void endProfiling2(this.sessionId);
        }
      };
    }
  });

  // web/lib/backend-wasm.ts
  var backend_wasm_exports = {};
  __export(backend_wasm_exports, {
    OnnxruntimeWebAssemblyBackend: () => OnnxruntimeWebAssemblyBackend,
    initializeFlags: () => initializeFlags,
    wasmBackend: () => wasmBackend
  });
  var initializeFlags, OnnxruntimeWebAssemblyBackend, wasmBackend;
  var init_backend_wasm = __esm({
    "web/lib/backend-wasm.ts"() {
      "use strict";
      init_esm();
      init_proxy_wrapper();
      init_session_handler_inference();
      initializeFlags = () => {
        if (typeof env2.wasm.initTimeout !== "number" || env2.wasm.initTimeout < 0) {
          env2.wasm.initTimeout = 0;
        }
        const simd = env2.wasm.simd;
        if (typeof simd !== "boolean" && simd !== void 0 && simd !== "fixed" && simd !== "relaxed") {
          console.warn(
            `Property "env.wasm.simd" is set to unknown value "${simd}". Reset it to \`false\` and ignore SIMD feature checking.`
          );
          env2.wasm.simd = false;
        }
        if (typeof env2.wasm.proxy !== "boolean") {
          env2.wasm.proxy = false;
        }
        if (typeof env2.wasm.trace !== "boolean") {
          env2.wasm.trace = false;
        }
        if (typeof env2.wasm.numThreads !== "number" || !Number.isInteger(env2.wasm.numThreads) || env2.wasm.numThreads <= 0) {
          if (typeof self !== "undefined" && !self.crossOriginIsolated) {
            env2.wasm.numThreads = 1;
          } else {
            const numCpuLogicalCores = typeof navigator === "undefined" ? __require("node:os").cpus().length : navigator.hardwareConcurrency;
            env2.wasm.numThreads = Math.min(4, Math.ceil((numCpuLogicalCores || 1) / 2));
          }
        }
      };
      OnnxruntimeWebAssemblyBackend = class {
        /**
         * This function initializes the WebAssembly backend.
         *
         * This function will be called only once for each backend name. It will be called the first time when
         * `ort.InferenceSession.create()` is called with a registered backend name.
         *
         * @param backendName - the registered backend name.
         */
        async init(backendName) {
          initializeFlags();
          await initializeWebAssemblyAndOrtRuntime();
          await initializeOrtEp(backendName);
        }
        async createInferenceSessionHandler(pathOrBuffer, options) {
          const handler = new OnnxruntimeWebAssemblySessionHandler();
          await handler.loadModel(pathOrBuffer, options);
          return handler;
        }
      };
      wasmBackend = new OnnxruntimeWebAssemblyBackend();
    }
  });

  // web/lib/index.ts
  var index_exports = {};
  __export(index_exports, {
    InferenceSession: () => InferenceSession2,
    TRACE: () => TRACE,
    TRACE_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,
    default: () => index_default,
    env: () => env2,
    registerBackend: () => registerBackend
  });
  init_esm();
  init_esm();
  init_esm();

  // web/lib/version.ts
  var version2 = "1.26.0";

  // web/lib/index.ts
  var index_default = esm_exports;
  if (false) {
    const onnxjsBackend = null.onnxjsBackend;
    registerBackend("webgl", onnxjsBackend, -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 (true) {
    const wasmBackend2 = (init_backend_wasm(), __toCommonJS(backend_wasm_exports)).wasmBackend;
    if (true) {
      registerBackend("webgpu", wasmBackend2, 5);
    }
    if (true) {
      registerBackend("webnn", wasmBackend2, 5);
    }
    registerBackend("cpu", wasmBackend2, 10);
    registerBackend("wasm", wasmBackend2, 10);
  }
  Object.defineProperty(env2.versions, "web", { value: version2, enumerable: true });
  return __toCommonJS(index_exports);
})();
/**
 * @license
 * Copyright 2021 Google LLC. All Rights Reserved.
 * 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.
 * =============================================================================
 */
/**
 * @license
 * Copyright 2020 Google LLC. All Rights Reserved.
 * 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.
 * =============================================================================
 */
/**
 * @license
 * Copyright 2019 Google LLC. All Rights Reserved.
 * 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.
 * =============================================================================
 */
typeof exports=="object"&&typeof module=="object"&&(module.exports=ort);
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../common/lib/backend-impl.ts", "../../common/lib/backend.ts", "../../common/lib/version.ts", "../../common/lib/env-impl.ts", "../../common/lib/env.ts", "../../common/lib/tensor-conversion-impl.ts", "../../common/lib/tensor-factory-impl.ts", "../../common/lib/tensor-impl-type-mapping.ts", "../../common/lib/tensor-utils-impl.ts", "../../common/lib/tensor-impl.ts", "../../common/lib/tensor.ts", "../../common/lib/trace.ts", "../../common/lib/inference-session-impl.ts", "../../common/lib/inference-session.ts", "../../common/lib/tensor-conversion.ts", "../../common/lib/tensor-factory.ts", "../../common/lib/onnx-model.ts", "../../common/lib/onnx-value.ts", "../../common/lib/index.ts", "../lib/wasm/wasm-utils-env.ts", "../lib/wasm/proxy-worker/main.ts", "../lib/wasm/wasm-utils-import.ts", "../lib/wasm/wasm-factory.ts", "../lib/wasm/wasm-utils.ts", "../lib/wasm/run-options.ts", "../lib/wasm/session-options.ts", "../lib/wasm/wasm-common.ts", "../lib/wasm/wasm-utils-load-file.ts", "../lib/wasm/jsep/log.ts", "../lib/wasm/jsep/util.ts", "../lib/wasm/jsep/tensor-view.ts", "../lib/wasm/jsep/webnn/tensor-manager.ts", "../lib/wasm/jsep/backend-webnn.ts", "../lib/wasm/jsep/webgpu/types.ts", "../lib/wasm/jsep/webgpu/gpu-data-manager.ts", "../lib/wasm/jsep/webgpu/attribute-with-cache-key.ts", "../lib/wasm/jsep/webgpu/ops/common.ts", "../lib/wasm/jsep/webgpu/ops/transpose.ts", "../lib/wasm/jsep/webgpu/ops/reduce-shared.ts", "../lib/wasm/jsep/webgpu/ops/reduce.ts", "../lib/wasm/jsep/webgpu/ops/argminmax.ts", "../lib/wasm/jsep/webgpu/ops/attention.ts", "../lib/wasm/jsep/webgpu/ops/batch-norm.ts", "../lib/wasm/jsep/webgpu/ops/bias-add.ts", "../lib/wasm/jsep/webgpu/ops/unary-op.ts", "../lib/wasm/jsep/webgpu/ops/bias-split-gelu.ts", "../lib/wasm/jsep/webgpu/ops/binary-op.ts", "../lib/wasm/jsep/webgpu/ops/concat.ts", "../lib/wasm/jsep/webgpu/ops/fuse-utils.ts", "../lib/wasm/jsep/webgpu/ops/3rd-party/activation_util.ts", "../lib/wasm/jsep/webgpu/ops/3rd-party/conv_util.ts", "../lib/wasm/jsep/webgpu/ops/matmul-shaders.ts", "../lib/wasm/jsep/webgpu/ops/3rd-party/matmul_packed_webgpu.ts", "../lib/wasm/jsep/webgpu/ops/3rd-party/conv2d_mm_webgpu.ts", "../lib/wasm/jsep/webgpu/ops/3rd-party/conv3d_naive_webgpu.ts", "../lib/wasm/jsep/webgpu/ops/conv-grouped.ts", "../lib/wasm/jsep/webgpu/ops/conv.ts", "../lib/wasm/jsep/webgpu/ops/3rd-party/conv_backprop_webgpu.ts", "../lib/wasm/jsep/webgpu/ops/conv-transpose.ts", "../lib/wasm/jsep/webgpu/ops/cumsum.ts", "../lib/wasm/jsep/webgpu/ops/depth-to-space.ts", "../lib/wasm/jsep/webgpu/ops/einsum.ts", "../lib/wasm/jsep/webgpu/ops/expand.ts", "../lib/wasm/jsep/webgpu/ops/fast-gelu.ts", "../lib/wasm/jsep/webgpu/ops/gather.ts", "../lib/wasm/jsep/webgpu/ops/gather-nd.ts", "../lib/wasm/jsep/webgpu/ops/gather-block-quantized.ts", "../lib/wasm/jsep/webgpu/ops/gather-elements.ts", "../lib/wasm/jsep/webgpu/ops/gemm.ts", "../lib/wasm/jsep/webgpu/ops/grid-sample.ts", "../lib/wasm/jsep/webgpu/ops/multihead-attention.ts", "../lib/wasm/jsep/webgpu/ops/split.ts", "../lib/wasm/jsep/webgpu/ops/rotary-embedding.ts", "../lib/wasm/jsep/webgpu/ops/group-query-attention.ts", "../lib/wasm/jsep/webgpu/ops/instance-norm.ts", "../lib/wasm/jsep/webgpu/ops/layer-norm.ts", "../lib/wasm/jsep/webgpu/ops/matmul.ts", "../lib/wasm/jsep/webgpu/ops/matmulnbits.ts", "../lib/wasm/jsep/webgpu/ops/pad.ts", "../lib/wasm/jsep/webgpu/ops/pool.ts", "../lib/wasm/jsep/webgpu/ops/quantize-linear.ts", "../lib/wasm/jsep/webgpu/ops/range.ts", "../lib/wasm/jsep/webgpu/ops/scatter-nd.ts", "../lib/wasm/jsep/webgpu/ops/resize.ts", "../lib/wasm/jsep/webgpu/ops/skip-layer-norm.ts", "../lib/wasm/jsep/webgpu/ops/slice.ts", "../lib/wasm/jsep/webgpu/ops/softmax.ts", "../lib/wasm/jsep/webgpu/ops/tile.ts", "../lib/wasm/jsep/webgpu/ops/where.ts", "../lib/wasm/jsep/webgpu/op-resolve-rules.ts", "../lib/wasm/jsep/webgpu/program-manager.ts", "../lib/wasm/jsep/backend-webgpu.ts", "../lib/wasm/jsep/init.ts", "../lib/wasm/wasm-core-impl.ts", "../lib/wasm/proxy-wrapper.ts", "../lib/wasm/session-handler-inference.ts", "../lib/backend-wasm.ts", "../lib/index.ts", "../lib/version.ts"],
  "sourcesContent": ["// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Backend } from './backend.js';\nimport { InferenceSession } from './inference-session.js';\n\ninterface BackendInfo {\n  backend: Backend;\n  priority: number;\n\n  initPromise?: Promise<void>;\n  initialized?: boolean;\n  aborted?: boolean;\n  error?: string;\n}\n\nconst backends: Map<string, BackendInfo> = new Map();\nconst backendsSortedByPriority: string[] = [];\n\n/**\n * Register a backend.\n *\n * @param name - the name as a key to lookup as an execution provider.\n * @param backend - the backend object.\n * @param priority - an integer indicating the priority of the backend. Higher number means higher priority. if priority\n * < 0, it will be considered as a 'beta' version and will not be used as a fallback backend by default.\n *\n * @ignore\n */\nexport const registerBackend = (name: string, backend: Backend, priority: number): void => {\n  if (backend && typeof backend.init === 'function' && typeof backend.createInferenceSessionHandler === 'function') {\n    const currentBackend = backends.get(name);\n    if (currentBackend === undefined) {\n      backends.set(name, { backend, priority });\n    } else if (currentBackend.priority > priority) {\n      // same name is already registered with a higher priority. skip registeration.\n      return;\n    } else if (currentBackend.priority === priority) {\n      if (currentBackend.backend !== backend) {\n        throw new Error(`cannot register backend \"${name}\" using priority ${priority}`);\n      }\n    }\n\n    if (priority >= 0) {\n      const i = backendsSortedByPriority.indexOf(name);\n      if (i !== -1) {\n        backendsSortedByPriority.splice(i, 1);\n      }\n\n      for (let i = 0; i < backendsSortedByPriority.length; i++) {\n        if (backends.get(backendsSortedByPriority[i])!.priority <= priority) {\n          backendsSortedByPriority.splice(i, 0, name);\n          return;\n        }\n      }\n      backendsSortedByPriority.push(name);\n    }\n    return;\n  }\n\n  throw new TypeError('not a valid backend');\n};\n\n/**\n * Try to resolve and initialize a backend.\n *\n * @param backendName - the name of the backend.\n * @returns the backend instance if resolved and initialized successfully, or an error message if failed.\n */\nconst tryResolveAndInitializeBackend = async (backendName: string): Promise<Backend | string> => {\n  const backendInfo = backends.get(backendName);\n  if (!backendInfo) {\n    return 'backend not found.';\n  }\n\n  if (backendInfo.initialized) {\n    return backendInfo.backend;\n  } else if (backendInfo.aborted) {\n    return backendInfo.error!;\n  } else {\n    const isInitializing = !!backendInfo.initPromise;\n    try {\n      if (!isInitializing) {\n        backendInfo.initPromise = backendInfo.backend.init(backendName);\n      }\n      await backendInfo.initPromise;\n      backendInfo.initialized = true;\n      return backendInfo.backend;\n    } catch (e) {\n      if (!isInitializing) {\n        backendInfo.error = `${e}`;\n        backendInfo.aborted = true;\n      }\n      return backendInfo.error!;\n    } finally {\n      delete backendInfo.initPromise;\n    }\n  }\n};\n\n/**\n * Resolve execution providers from the specific session options.\n *\n * @param options - the session options object.\n * @returns a promise that resolves to a tuple of an initialized backend instance and a session options object with\n * filtered EP list.\n *\n * @ignore\n */\nexport const resolveBackendAndExecutionProviders = async (\n  options: InferenceSession.SessionOptions,\n): Promise<[backend: Backend, options: InferenceSession.SessionOptions]> => {\n  // extract backend hints from session options\n  const eps = options.executionProviders || [];\n  const backendHints = eps.map((i) => (typeof i === 'string' ? i : i.name));\n  const backendNames = backendHints.length === 0 ? backendsSortedByPriority : backendHints;\n\n  // try to resolve and initialize all requested backends\n  let backend: Backend | undefined;\n  const errors = [];\n  const availableBackendNames = new Set<string>();\n  for (const backendName of backendNames) {\n    const resolveResult = await tryResolveAndInitializeBackend(backendName);\n    if (typeof resolveResult === 'string') {\n      errors.push({ name: backendName, err: resolveResult });\n    } else {\n      if (!backend) {\n        backend = resolveResult;\n      }\n      if (backend === resolveResult) {\n        availableBackendNames.add(backendName);\n      }\n    }\n  }\n\n  // if no backend is available, throw error.\n  if (!backend) {\n    throw new Error(`no available backend found. ERR: ${errors.map((e) => `[${e.name}] ${e.err}`).join(', ')}`);\n  }\n\n  // for each explicitly requested backend, if it's not available, output warning message.\n  for (const { name, err } of errors) {\n    if (backendHints.includes(name)) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        `removing requested execution provider \"${name}\" from session options because it is not available: ${err}`,\n      );\n    }\n  }\n\n  const filteredEps = eps.filter((i) => availableBackendNames.has(typeof i === 'string' ? i : i.name));\n\n  return [\n    backend,\n    new Proxy(options, {\n      get: (target, prop) => {\n        if (prop === 'executionProviders') {\n          return filteredEps;\n        }\n        return Reflect.get(target, prop);\n      },\n    }),\n  ];\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { InferenceSession } from './inference-session.js';\nimport { OnnxValue } from './onnx-value.js';\n\n/**\n * @ignore\n */\nexport declare namespace SessionHandler {\n  type FeedsType = { [name: string]: OnnxValue };\n  type FetchesType = { [name: string]: OnnxValue | null };\n  type ReturnType = { [name: string]: OnnxValue };\n}\n\n/**\n * Represents shared SessionHandler functionality\n *\n * @ignore\n */\ninterface SessionHandler {\n  dispose(): Promise<void>;\n\n  readonly inputNames: readonly string[];\n  readonly outputNames: readonly string[];\n\n  readonly inputMetadata: readonly InferenceSession.ValueMetadata[];\n  readonly outputMetadata: readonly InferenceSession.ValueMetadata[];\n}\n\n/**\n * Represent a handler instance of an inference session.\n *\n * @ignore\n */\nexport interface InferenceSessionHandler extends SessionHandler {\n  startProfiling(): void;\n  endProfiling(): void;\n\n  run(\n    feeds: SessionHandler.FeedsType,\n    fetches: SessionHandler.FetchesType,\n    options: InferenceSession.RunOptions,\n  ): Promise<SessionHandler.ReturnType>;\n}\n\n/**\n * Represent a backend that provides implementation of model inferencing.\n *\n * @ignore\n */\nexport interface Backend {\n  /**\n   * Initialize the backend asynchronously. Should throw when failed.\n   */\n  init(backendName: string): Promise<void>;\n\n  createInferenceSessionHandler(\n    uriOrBuffer: string | Uint8Array,\n    options?: InferenceSession.SessionOptions,\n  ): Promise<InferenceSessionHandler>;\n}\n\nexport { registerBackend } from './backend-impl.js';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// This file is generated by /js/scripts/update-version.ts\n// Do not modify file content manually.\n\nexport const version = '1.26.0';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Env } from './env.js';\nimport { version } from './version.js';\n\ntype LogLevelType = Env['logLevel'];\n\nlet logLevelValue: Required<LogLevelType> = 'warning';\n\nexport const env: Env = {\n  wasm: {} as Env.WebAssemblyFlags,\n  webgl: {} as Env.WebGLFlags,\n  webgpu: {} as Env.WebGpuFlags,\n  versions: { common: version },\n\n  set logLevel(value: LogLevelType) {\n    if (value === undefined) {\n      return;\n    }\n    if (typeof value !== 'string' || ['verbose', 'info', 'warning', 'error', 'fatal'].indexOf(value) === -1) {\n      throw new Error(`Unsupported logging level: ${value}`);\n    }\n    logLevelValue = value;\n  },\n  get logLevel(): Required<LogLevelType> {\n    return logLevelValue;\n  },\n};\n\n// set property 'logLevel' so that they can be correctly transferred to worker by `postMessage()`.\nObject.defineProperty(env, 'logLevel', { enumerable: true });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { env as envImpl } from './env-impl.js';\nimport { TryGetGlobalType } from './type-helper.js';\n\nexport declare namespace Env {\n  export type WasmPathPrefix = string;\n  export interface WasmFilePaths {\n    /**\n     * Specify the override path for the main .wasm file.\n     *\n     * This path should be an absolute path.\n     *\n     * If not modified, the filename of the .wasm file is:\n     * - `ort-wasm-simd-threaded.wasm` for default build\n     * - `ort-wasm-simd-threaded.jsep.wasm` for JSEP build (with WebGPU and WebNN)\n     * - `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,\n    OptionsTensorLayout,\n    OptionsNormalizationParameters,\n    OptionsFormat,\n    OptionsTensorFormat {}\n\n/**\n * Create a new tensor object from image object\n *\n * @param buffer - Extracted image buffer data - assuming RGBA format\n * @param imageFormat - input image configuration - required configurations height, width, format\n * @param tensorFormat - output tensor configuration - Default is RGB format\n */\nexport const bufferToTensor = (buffer: Uint8ClampedArray | undefined, options: BufferToTensorOptions): Tensor => {\n  if (buffer === undefined) {\n    throw new Error('Image buffer must be defined');\n  }\n  if (options.height === undefined || options.width === undefined) {\n    throw new Error('Image height and width must be defined');\n  }\n  if (options.tensorLayout === 'NHWC') {\n    throw new Error('NHWC Tensor layout is not supported yet');\n  }\n\n  const { height, width } = options;\n\n  const norm = options.norm ?? { mean: 255, bias: 0 };\n  let normMean: [number, number, number, number];\n  let normBias: [number, number, number, number];\n\n  if (typeof norm.mean === 'number') {\n    normMean = [norm.mean, norm.mean, norm.mean, norm.mean];\n  } else {\n    normMean = [norm.mean![0], norm.mean![1], norm.mean![2], norm.mean![3] ?? 255];\n  }\n\n  if (typeof norm.bias === 'number') {\n    normBias = [norm.bias, norm.bias, norm.bias, norm.bias];\n  } else {\n    normBias = [norm.bias![0], norm.bias![1], norm.bias![2], norm.bias![3] ?? 0];\n  }\n\n  const inputformat = options.format !== undefined ? options.format : 'RGBA';\n  // default value is RGBA since imagedata and HTMLImageElement uses it\n\n  const outputformat =\n    options.tensorFormat !== undefined ? (options.tensorFormat !== undefined ? options.tensorFormat : 'RGB') : 'RGB';\n  const stride = height * width;\n  const float32Data = outputformat === 'RGBA' ? new Float32Array(stride * 4) : new Float32Array(stride * 3);\n\n  // Default pointer assignments\n  let step = 4,\n    rImagePointer = 0,\n    gImagePointer = 1,\n    bImagePointer = 2,\n    aImagePointer = 3;\n  let rTensorPointer = 0,\n    gTensorPointer = stride,\n    bTensorPointer = stride * 2,\n    aTensorPointer = -1;\n\n  // Updating the pointer assignments based on the input image format\n  if (inputformat === 'RGB') {\n    step = 3;\n    rImagePointer = 0;\n    gImagePointer = 1;\n    bImagePointer = 2;\n    aImagePointer = -1;\n  }\n\n  // Updating the pointer assignments based on the output tensor format\n  if (outputformat === 'RGBA') {\n    aTensorPointer = stride * 3;\n  } else if (outputformat === 'RBG') {\n    rTensorPointer = 0;\n    bTensorPointer = stride;\n    gTensorPointer = stride * 2;\n  } else if (outputformat === 'BGR') {\n    bTensorPointer = 0;\n    gTensorPointer = stride;\n    rTensorPointer = stride * 2;\n  }\n\n  for (\n    let i = 0;\n    i < stride;\n    i++, rImagePointer += step, bImagePointer += step, gImagePointer += step, aImagePointer += step\n  ) {\n    float32Data[rTensorPointer++] = (buffer[rImagePointer] + normBias[0]) / normMean[0];\n    float32Data[gTensorPointer++] = (buffer[gImagePointer] + normBias[1]) / normMean[1];\n    float32Data[bTensorPointer++] = (buffer[bImagePointer] + normBias[2]) / normMean[2];\n    if (aTensorPointer !== -1 && aImagePointer !== -1) {\n      float32Data[aTensorPointer++] = (buffer[aImagePointer] + normBias[3]) / normMean[3];\n    }\n  }\n\n  // Float32Array -> ort.Tensor\n  const outputTensor =\n    outputformat === 'RGBA'\n      ? new Tensor('float32', float32Data, [1, 4, height, width])\n      : new Tensor('float32', float32Data, [1, 3, height, width]);\n  return outputTensor;\n};\n\n/**\n * implementation of Tensor.fromImage().\n */\nexport const tensorFromImage = async (\n  image: ImageData | HTMLImageElement | ImageBitmap | string,\n  options?:\n    | TensorFromImageDataOptions\n    | TensorFromImageElementOptions\n    | TensorFromImageBitmapOptions\n    | TensorFromUrlOptions,\n): Promise<Tensor> => {\n  // checking the type of image object\n  const isHTMLImageEle = typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement;\n  const isImageDataEle = typeof ImageData !== 'undefined' && image instanceof ImageData;\n  const isImageBitmap = typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap;\n  const isString = typeof image === 'string';\n\n  let data: Uint8ClampedArray | undefined;\n  let bufferToTensorOptions: BufferToTensorOptions = options ?? {};\n\n  const createCanvas = () => {\n    if (typeof document !== 'undefined') {\n      return document.createElement('canvas');\n    } else if (typeof OffscreenCanvas !== 'undefined') {\n      return new OffscreenCanvas(1, 1);\n    } else {\n      throw new Error('Canvas is not supported');\n    }\n  };\n  const createCanvasContext = (canvas: HTMLCanvasElement | OffscreenCanvas) => {\n    if (typeof HTMLCanvasElement !== 'undefined' && canvas instanceof HTMLCanvasElement) {\n      return canvas.getContext('2d');\n    } else if (canvas instanceof OffscreenCanvas) {\n      return canvas.getContext('2d') as OffscreenCanvasRenderingContext2D;\n    } else {\n      return null;\n    }\n  };\n  // filling and checking image configuration options\n  if (isHTMLImageEle) {\n    // HTMLImageElement - image object - format is RGBA by default\n    const canvas = createCanvas();\n    canvas.width = image.width;\n    canvas.height = image.height;\n    const pixels2DContext = createCanvasContext(canvas);\n\n    if (pixels2DContext != null) {\n      let height = image.height;\n      let width = image.width;\n      if (options !== undefined && options.resizedHeight !== undefined && options.resizedWidth !== undefined) {\n        height = options.resizedHeight;\n        width = options.resizedWidth;\n      }\n\n      if (options !== undefined) {\n        bufferToTensorOptions = options;\n        if (options.tensorFormat !== undefined) {\n          throw new Error('Image input config format must be RGBA for HTMLImageElement');\n        } else {\n          bufferToTensorOptions.tensorFormat = 'RGBA';\n        }\n        bufferToTensorOptions.height = height;\n        bufferToTensorOptions.width = width;\n      } else {\n        bufferToTensorOptions.tensorFormat = 'RGBA';\n        bufferToTensorOptions.height = height;\n        bufferToTensorOptions.width = width;\n      }\n\n      pixels2DContext.drawImage(image, 0, 0);\n      data = pixels2DContext.getImageData(0, 0, width, height).data;\n    } else {\n      throw new Error('Can not access image data');\n    }\n  } else if (isImageDataEle) {\n    let height: number;\n    let width: number;\n\n    if (options !== undefined && options.resizedWidth !== undefined && options.resizedHeight !== undefined) {\n      height = options.resizedHeight;\n      width = options.resizedWidth;\n    } else {\n      height = image.height;\n      width = image.width;\n    }\n\n    if (options !== undefined) {\n      bufferToTensorOptions = options;\n    }\n    bufferToTensorOptions.format = 'RGBA';\n    bufferToTensorOptions.height = height;\n    bufferToTensorOptions.width = width;\n\n    if (options !== undefined) {\n      const tempCanvas = createCanvas();\n\n      tempCanvas.width = width;\n      tempCanvas.height = height;\n\n      const pixels2DContext = createCanvasContext(tempCanvas);\n\n      if (pixels2DContext != null) {\n        pixels2DContext.putImageData(image, 0, 0);\n        data = pixels2DContext.getImageData(0, 0, width, height).data;\n      } else {\n        throw new Error('Can not access image data');\n      }\n    } else {\n      data = image.data;\n    }\n  } else if (isImageBitmap) {\n    // ImageBitmap - image object - format must be provided by user\n    if (options === undefined) {\n      throw new Error('Please provide image config with format for Imagebitmap');\n    }\n\n    const canvas = createCanvas();\n    canvas.width = image.width;\n    canvas.height = image.height;\n    const pixels2DContext = createCanvasContext(canvas);\n\n    if (pixels2DContext != null) {\n      const height = image.height;\n      const width = image.width;\n      pixels2DContext.drawImage(image, 0, 0, width, height);\n      data = pixels2DContext.getImageData(0, 0, width, height).data;\n      bufferToTensorOptions.height = height;\n      bufferToTensorOptions.width = width;\n      return bufferToTensor(data, bufferToTensorOptions);\n    } else {\n      throw new Error('Can not access image data');\n    }\n  } else if (isString) {\n    return new Promise((resolve, reject) => {\n      const canvas = createCanvas();\n      const context = createCanvasContext(canvas);\n      if (!image || !context) {\n        return reject();\n      }\n      const newImage = new Image();\n      newImage.crossOrigin = 'Anonymous';\n      newImage.src = image;\n      newImage.onload = () => {\n        canvas.width = newImage.width;\n        canvas.height = newImage.height;\n        context.drawImage(newImage, 0, 0, canvas.width, canvas.height);\n        const img = context.getImageData(0, 0, canvas.width, canvas.height);\n\n        bufferToTensorOptions.height = canvas.height;\n        bufferToTensorOptions.width = canvas.width;\n        resolve(bufferToTensor(img.data, bufferToTensorOptions));\n      };\n    });\n  } else {\n    throw new Error('Input data provided is not supported - aborted tensor creation');\n  }\n\n  if (data !== undefined) {\n    return bufferToTensor(data, bufferToTensorOptions);\n  } else {\n    throw new Error('Input data provided is not supported - aborted tensor creation');\n  }\n};\n\n/**\n * implementation of Tensor.fromTexture().\n */\nexport const tensorFromTexture = <T extends TensorInterface.TextureDataTypes>(\n  texture: TensorInterface.TextureType,\n  options: TensorFromTextureOptions<T>,\n): Tensor => {\n  const { width, height, download, dispose } = options;\n  // Always assume RGBAF32. TODO: support different texture format\n  const dims = [1, height, width, 4];\n  return new Tensor({ location: 'texture', type: 'float32', texture, dims, download, dispose });\n};\n\n/**\n * implementation of Tensor.fromGpuBuffer().\n */\nexport const tensorFromGpuBuffer = <T extends TensorInterface.GpuBufferDataTypes>(\n  gpuBuffer: TensorInterface.GpuBufferType,\n  options: TensorFromGpuBufferOptions<T>,\n): Tensor => {\n  const { dataType, dims, download, dispose } = options;\n  return new Tensor({ location: 'gpu-buffer', type: dataType ?? 'float32', gpuBuffer, dims, download, dispose });\n};\n\n/**\n * implementation of Tensor.fromMLTensor().\n */\nexport const tensorFromMLTensor = <T extends TensorInterface.MLTensorDataTypes>(\n  mlTensor: TensorInterface.MLTensorType,\n  options: TensorFromMLTensorOptions<T>,\n): Tensor => {\n  const { dataType, dims, download, dispose } = options;\n  return new Tensor({ location: 'ml-tensor', type: dataType ?? 'float32', mlTensor, dims, download, dispose });\n};\n\n/**\n * implementation of Tensor.fromPinnedBuffer().\n */\nexport const tensorFromPinnedBuffer = <T extends TensorInterface.CpuPinnedDataTypes>(\n  type: T,\n  buffer: TensorInterface.DataTypeMap[T],\n  dims?: readonly number[],\n): Tensor => new Tensor({ location: 'cpu-pinned', type, data: buffer, dims: dims ?? [buffer.length] });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from './tensor.js';\n\nexport type SupportedTypedArrayConstructors =\n  | Float32ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int8ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int16ArrayConstructor\n  | Int32ArrayConstructor\n  | BigInt64ArrayConstructor\n  | Uint8ArrayConstructor\n  | Float64ArrayConstructor\n  | Uint32ArrayConstructor\n  | BigUint64ArrayConstructor;\nexport type SupportedTypedArray = InstanceType<SupportedTypedArrayConstructors>;\n\n// a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.\nexport const NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP = new Map<string, SupportedTypedArrayConstructors>([\n  ['float32', Float32Array],\n  ['uint8', Uint8Array],\n  ['int8', Int8Array],\n  ['uint16', Uint16Array],\n  ['int16', Int16Array],\n  ['int32', Int32Array],\n  ['bool', Uint8Array],\n  ['float64', Float64Array],\n  ['uint32', Uint32Array],\n  ['int4', Uint8Array],\n  ['uint4', Uint8Array],\n]);\n\n// a runtime map that maps type string to TypedArray constructor. Should match Tensor.DataTypeMap.\nexport const NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP = new Map<SupportedTypedArrayConstructors, Tensor.Type>([\n  [Float32Array, 'float32'],\n  [Uint8Array, 'uint8'],\n  [Int8Array, 'int8'],\n  [Uint16Array, 'uint16'],\n  [Int16Array, 'int16'],\n  [Int32Array, 'int32'],\n  [Float64Array, 'float64'],\n  [Uint32Array, 'uint32'],\n]);\n\n// the following code allows delaying execution of BigInt/Float16Array checking. This allows lazy initialization for\n// NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP and NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP, which allows BigInt/Float16Array\n// polyfill if available.\nlet isTypedArrayChecked = false;\nexport const checkTypedArray = () => {\n  if (!isTypedArrayChecked) {\n    isTypedArrayChecked = true;\n    const isBigInt64ArrayAvailable = typeof BigInt64Array !== 'undefined' && BigInt64Array.from;\n    const isBigUint64ArrayAvailable = typeof BigUint64Array !== 'undefined' && BigUint64Array.from;\n\n    // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any\n    const Float16Array = (globalThis as any).Float16Array;\n    const isFloat16ArrayAvailable = typeof Float16Array !== 'undefined' && Float16Array.from;\n\n    if (isBigInt64ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('int64', BigInt64Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigInt64Array, 'int64');\n    }\n    if (isBigUint64ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('uint64', BigUint64Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(BigUint64Array, 'uint64');\n    }\n    if (isFloat16ArrayAvailable) {\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('float16', Float16Array);\n      NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.set(Float16Array, 'float16');\n    } else {\n      // if Float16Array is not available, use 'Uint16Array' to store the data.\n      NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.set('float16', Uint16Array);\n    }\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {\n  CpuPinnedConstructorParameters,\n  GpuBufferConstructorParameters,\n  MLTensorConstructorParameters,\n  TextureConstructorParameters,\n} from './tensor-factory.js';\nimport { Tensor } from './tensor-impl.js';\n\n/**\n * calculate size from dims.\n *\n * @param dims the dims array. May be an illegal input.\n */\nexport const calculateSize = (dims: readonly unknown[]): number => {\n  let size = 1;\n  for (let i = 0; i < dims.length; i++) {\n    const dim = dims[i];\n    if (typeof dim !== 'number' || !Number.isSafeInteger(dim)) {\n      throw new TypeError(`dims[${i}] must be an integer, got: ${dim}`);\n    }\n    if (dim < 0) {\n      throw new RangeError(`dims[${i}] must be a non-negative integer, got: ${dim}`);\n    }\n    size *= dim;\n  }\n  return size;\n};\n\n/**\n * implementation of Tensor.reshape()\n */\nexport const tensorReshape = (tensor: Tensor, dims: readonly number[]): Tensor => {\n  switch (tensor.location) {\n    case 'cpu':\n      return new Tensor(tensor.type, tensor.data, dims);\n    case 'cpu-pinned':\n      return new Tensor({\n        location: 'cpu-pinned',\n        data: tensor.data as CpuPinnedConstructorParameters['data'],\n        type: tensor.type as CpuPinnedConstructorParameters['type'],\n        dims,\n      });\n    case 'texture':\n      return new Tensor({\n        location: 'texture',\n        texture: tensor.texture,\n        type: tensor.type as TextureConstructorParameters['type'],\n        dims,\n      });\n    case 'gpu-buffer':\n      return new Tensor({\n        location: 'gpu-buffer',\n        gpuBuffer: tensor.gpuBuffer,\n        type: tensor.type as GpuBufferConstructorParameters['type'],\n        dims,\n      });\n    case 'ml-tensor':\n      return new Tensor({\n        location: 'ml-tensor',\n        mlTensor: tensor.mlTensor,\n        type: tensor.type as MLTensorConstructorParameters['type'],\n        dims,\n      });\n    default:\n      throw new Error(`tensorReshape: tensor location ${tensor.location} is not supported`);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { tensorToDataURL, tensorToImageData } from './tensor-conversion-impl.js';\nimport { TensorToDataUrlOptions, TensorToImageDataOptions } from './tensor-conversion.js';\nimport {\n  tensorFromGpuBuffer,\n  tensorFromImage,\n  tensorFromMLTensor,\n  tensorFromPinnedBuffer,\n  tensorFromTexture,\n} from './tensor-factory-impl.js';\nimport {\n  CpuPinnedConstructorParameters,\n  GpuBufferConstructorParameters,\n  MLTensorConstructorParameters,\n  TensorFromGpuBufferOptions,\n  TensorFromImageBitmapOptions,\n  TensorFromImageDataOptions,\n  TensorFromImageElementOptions,\n  TensorFromMLTensorOptions,\n  TensorFromTextureOptions,\n  TensorFromUrlOptions,\n  TextureConstructorParameters,\n} from './tensor-factory.js';\nimport {\n  checkTypedArray,\n  NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP,\n  NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP,\n  SupportedTypedArray,\n  SupportedTypedArrayConstructors,\n} from './tensor-impl-type-mapping.js';\nimport { calculateSize, tensorReshape } from './tensor-utils-impl.js';\nimport { Tensor as TensorInterface } from './tensor.js';\n\n// type aliases for those exported from Tensor interface\n\ntype TensorType = TensorInterface.Type;\ntype TensorDataType = TensorInterface.DataType;\ntype TensorDataLocation = TensorInterface.DataLocation;\ntype TensorTextureType = TensorInterface.TextureType;\ntype TensorGpuBufferType = TensorInterface.GpuBufferType;\ntype TensorMLTensorType = TensorInterface.MLTensorType;\n\n/**\n * the implementation of Tensor interface.\n *\n * @ignore\n */\nexport class Tensor implements TensorInterface {\n  // #region constructors\n\n  /**\n   * Construct a new CPU tensor object from the given type, data and dims.\n   */\n  constructor(\n    type: TensorType,\n    data: TensorDataType | Uint8ClampedArray | readonly string[] | readonly number[] | readonly boolean[],\n    dims?: readonly number[],\n  );\n  /**\n   * Construct a new CPU tensor object from the given data and dims. Type is inferred from data.\n   */\n  constructor(\n    data: TensorDataType | Uint8ClampedArray | readonly string[] | readonly boolean[],\n    dims?: readonly number[],\n  );\n  /**\n   * Construct a new tensor object from the pinned CPU data with the given type and dims.\n   *\n   * Tensor's location will be set to 'cpu-pinned'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: CpuPinnedConstructorParameters);\n  /**\n   * Construct a new tensor object from the WebGL texture with the given type and dims.\n   *\n   * Tensor's location will be set to 'texture'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: TextureConstructorParameters);\n  /**\n   * Construct a new tensor object from the WebGPU buffer with the given type and dims.\n   *\n   * Tensor's location will be set to 'gpu-buffer'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: GpuBufferConstructorParameters);\n\n  /**\n   * Construct a new tensor object from the WebNN MLTensor with the given type and dims.\n   *\n   * Tensor's location will be set to 'ml-tensor'.\n   *\n   * @param params - Specify the parameters to construct the tensor.\n   */\n  constructor(params: MLTensorConstructorParameters);\n\n  /**\n   * implementation.\n   */\n  constructor(\n    arg0:\n      | TensorType\n      | TensorDataType\n      | Uint8ClampedArray\n      | readonly string[]\n      | readonly boolean[]\n      | CpuPinnedConstructorParameters\n      | TextureConstructorParameters\n      | GpuBufferConstructorParameters\n      | MLTensorConstructorParameters,\n    arg1?: TensorDataType | Uint8ClampedArray | readonly number[] | readonly string[] | readonly boolean[],\n    arg2?: readonly number[],\n  ) {\n    // perform one-time check for BigInt/Float16Array support\n    checkTypedArray();\n\n    let type: TensorType;\n    let dims: readonly number[];\n\n    if (typeof arg0 === 'object' && 'location' in arg0) {\n      //\n      // constructing tensor from specific location\n      //\n      this.dataLocation = arg0.location;\n      type = arg0.type;\n      dims = arg0.dims;\n      switch (arg0.location) {\n        case 'cpu-pinned': {\n          const expectedTypedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(type);\n          if (!expectedTypedArrayConstructor) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from pinned buffer`);\n          }\n          if (!(arg0.data instanceof expectedTypedArrayConstructor)) {\n            throw new TypeError(`buffer should be of type ${expectedTypedArrayConstructor.name}`);\n          }\n          this.cpuData = arg0.data;\n          break;\n        }\n        case 'texture': {\n          if (type !== 'float32') {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from texture`);\n          }\n          this.gpuTextureData = arg0.texture;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        case 'gpu-buffer': {\n          if (\n            type !== 'float32' &&\n            type !== 'float16' &&\n            type !== 'int32' &&\n            type !== 'int64' &&\n            type !== 'uint32' &&\n            type !== 'uint8' &&\n            type !== 'bool' &&\n            type !== 'uint4' &&\n            type !== 'int4'\n          ) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from gpu buffer`);\n          }\n          this.gpuBufferData = arg0.gpuBuffer;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        case 'ml-tensor': {\n          if (\n            type !== 'float32' &&\n            type !== 'float16' &&\n            type !== 'int32' &&\n            type !== 'int64' &&\n            type !== 'uint32' &&\n            type !== 'uint64' &&\n            type !== 'int8' &&\n            type !== 'uint8' &&\n            type !== 'bool' &&\n            type !== 'uint4' &&\n            type !== 'int4'\n          ) {\n            throw new TypeError(`unsupported type \"${type}\" to create tensor from MLTensor`);\n          }\n          this.mlTensorData = arg0.mlTensor;\n          this.downloader = arg0.download;\n          this.disposer = arg0.dispose;\n          break;\n        }\n        default:\n          throw new Error(`Tensor constructor: unsupported location '${this.dataLocation}'`);\n      }\n    } else {\n      //\n      // constructing tensor of location 'cpu'\n      //\n      let data: TensorDataType;\n      let maybeDims: typeof arg1 | typeof arg2;\n      // check whether arg0 is type or data\n      if (typeof arg0 === 'string') {\n        //\n        // Override: constructor(type, data, ...)\n        //\n        type = arg0;\n        maybeDims = arg2;\n        if (arg0 === 'string') {\n          // string tensor\n          if (!Array.isArray(arg1)) {\n            throw new TypeError(\"A string tensor's data must be a string array.\");\n          }\n          // we don't check whether every element in the array is string; this is too slow. we assume it's correct and\n          // error will be populated at inference\n          data = arg1;\n        } else {\n          // numeric tensor\n          const typedArrayConstructor = NUMERIC_TENSOR_TYPE_TO_TYPEDARRAY_MAP.get(arg0);\n          if (typedArrayConstructor === undefined) {\n            throw new TypeError(`Unsupported tensor type: ${arg0}.`);\n          }\n          if (Array.isArray(arg1)) {\n            if ((arg0 === 'float16' && typedArrayConstructor === Uint16Array) || arg0 === 'uint4' || arg0 === 'int4') {\n              // - 'float16':\n              //   When no Float16Array polyfill is used, we cannot create 'float16' tensor from number array.\n              //\n              //   Throw error here because when user try to use number array as data,\n              //   e.g. new Tensor('float16', [1, 2, 3, 4], dims)), it will actually call\n              //   Uint16Array.from(arg1) which generates wrong data.\n              //\n              // - 'uint4' and 'int4':\n              //   Uint8Array.from(arg1) will generate wrong data for 'uint4' and 'int4' tensor.\n              //\n              throw new TypeError(\n                `Creating a ${arg0} tensor from number array is not supported. Please use ${typedArrayConstructor.name} as data.`,\n              );\n            } else if (arg0 === 'uint64' || arg0 === 'int64') {\n              // use 'as any' here because:\n              // 1. TypeScript's check on type of 'Array.isArray()' does not work with readonly arrays.\n              // see https://github.com/microsoft/TypeScript/issues/17002\n              // 2. TypeScript's check on union type of '(BigInt64ArrayConstructor|BigUint64ArrayConstructor).from()'\n              // does not accept parameter mapFn.\n              // 3. parameters of 'SupportedTypedArrayConstructors.from()' does not match the requirement of the union\n              // type.\n\n              // assume 'arg1' is of type \"readonly number[]|readonly bigint[]\" here.\n\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              data = (typedArrayConstructor as any).from(arg1, BigInt);\n            } else {\n              // assume 'arg1' is of type \"readonly number[]\" here.\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              data = (typedArrayConstructor as any).from(arg1);\n            }\n          } else if (arg1 instanceof typedArrayConstructor) {\n            data = arg1;\n          } else if (arg1 instanceof Uint8ClampedArray) {\n            if (arg0 === 'uint8') {\n              data = Uint8Array.from(arg1);\n            } else {\n              throw new TypeError(`A Uint8ClampedArray tensor's data must be type of uint8`);\n            }\n          } else if (arg0 === 'float16' && arg1 instanceof Uint16Array && typedArrayConstructor !== Uint16Array) {\n            // when Float16Array is available and data is of type Uint16Array.\n            // We allow Uint16Array to be passed in as data for 'float16' tensor until Float16Array is generally\n            // supported in JavaScript environment.\n\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            data = new (globalThis as any).Float16Array(arg1.buffer, arg1.byteOffset, arg1.length);\n          } else {\n            throw new TypeError(`A ${type} tensor's data must be type of ${typedArrayConstructor}`);\n          }\n        }\n      } else {\n        //\n        // Override: constructor(data, ...)\n        //\n        maybeDims = arg1;\n        if (Array.isArray(arg0)) {\n          // only boolean[] and string[] is supported\n          if (arg0.length === 0) {\n            throw new TypeError('Tensor type cannot be inferred from an empty array.');\n          }\n          const firstElementType = typeof arg0[0];\n          if (firstElementType === 'string') {\n            type = 'string';\n            data = arg0;\n          } else if (firstElementType === 'boolean') {\n            type = 'bool';\n            // 'arg0' is of type 'boolean[]'. Uint8Array.from(boolean[]) actually works, but typescript thinks this is\n            // wrong type. We use 'as any' to make it happy.\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            data = Uint8Array.from(arg0 as any[]);\n          } else {\n            throw new TypeError(`Invalid element type of data array: ${firstElementType}.`);\n          }\n        } else if (arg0 instanceof Uint8ClampedArray) {\n          type = 'uint8';\n          data = Uint8Array.from(arg0);\n        } else {\n          // get tensor type from TypedArray\n          const mappedType = NUMERIC_TENSOR_TYPEDARRAY_TO_TYPE_MAP.get(\n            arg0.constructor as SupportedTypedArrayConstructors,\n          );\n          if (mappedType === undefined) {\n            throw new TypeError(`Unsupported type for tensor data: ${arg0.constructor}.`);\n          }\n          type = mappedType;\n          data = arg0 as SupportedTypedArray;\n        }\n      }\n\n      // type and data is processed, now processing dims\n      if (maybeDims === undefined) {\n        // assume 1-D tensor if dims omitted\n        maybeDims = [data.length];\n      } else if (!Array.isArray(maybeDims)) {\n        throw new TypeError(\"A tensor's dims must be a number array\");\n      }\n      dims = maybeDims as readonly number[];\n\n      this.cpuData = data;\n      this.dataLocation = 'cpu';\n    }\n\n    // perform check on dims\n    const size = calculateSize(dims);\n    // if data is on CPU, check whether data length matches tensor size\n    if (this.cpuData && size !== this.cpuData.length) {\n      if ((type === 'uint4' || type === 'int4') && Math.ceil(size / 2) === this.cpuData.length) {\n        // for (u)int4, the data length is half of the tensor size. So we check this special case when size is odd.\n      } else {\n        throw new Error(`Tensor's size(${size}) does not match data length(${this.cpuData.length}).`);\n      }\n    }\n\n    this.type = type;\n    this.dims = dims;\n    this.size = size;\n  }\n  // #endregion\n\n  // #region factory\n  static async fromImage(\n    image: ImageData | HTMLImageElement | ImageBitmap | string,\n    options?:\n      | TensorFromImageDataOptions\n      | TensorFromImageElementOptions\n      | TensorFromImageBitmapOptions\n      | TensorFromUrlOptions,\n  ): Promise<TensorInterface> {\n    return tensorFromImage(image, options);\n  }\n\n  static fromTexture<T extends TensorInterface.TextureDataTypes>(\n    texture: TensorTextureType,\n    options: TensorFromTextureOptions<T>,\n  ): TensorInterface {\n    return tensorFromTexture(texture, options);\n  }\n\n  static fromGpuBuffer<T extends TensorInterface.GpuBufferDataTypes>(\n    gpuBuffer: TensorGpuBufferType,\n    options: TensorFromGpuBufferOptions<T>,\n  ): TensorInterface {\n    return tensorFromGpuBuffer(gpuBuffer, options);\n  }\n\n  static fromMLTensor<T extends TensorInterface.MLTensorDataTypes>(\n    mlTensor: TensorMLTensorType,\n    options: TensorFromMLTensorOptions<T>,\n  ): TensorInterface {\n    return tensorFromMLTensor(mlTensor, options);\n  }\n\n  static fromPinnedBuffer<T extends TensorInterface.CpuPinnedDataTypes>(\n    type: T,\n    buffer: TensorInterface.DataTypeMap[T],\n    dims?: readonly number[],\n  ): Tensor {\n    return tensorFromPinnedBuffer(type, buffer, dims);\n  }\n\n  // #endregion\n\n  // #region conversions\n  toDataURL(options?: TensorToDataUrlOptions): string {\n    return tensorToDataURL(this, options);\n  }\n\n  toImageData(options?: TensorToImageDataOptions): ImageData {\n    return tensorToImageData(this, options);\n  }\n  // #endregion\n\n  // #region public fields\n  readonly dims: readonly number[];\n  readonly type: TensorType;\n  readonly size: number;\n  // #endregion\n\n  // #region private fields\n\n  /**\n   * stores the location of the data.\n   */\n  private dataLocation: TensorDataLocation;\n\n  /**\n   * stores the data on CPU, if location is 'cpu' or 'cpu-pinned'. otherwise empty.\n   */\n  private cpuData?: TensorDataType;\n\n  /**\n   * stores the underlying texture when location is 'texture'. otherwise empty.\n   */\n  private gpuTextureData?: TensorTextureType;\n\n  /**\n   * stores the underlying GPU buffer when location is 'gpu-buffer'. otherwise empty.\n   */\n  private gpuBufferData?: TensorGpuBufferType;\n\n  /**\n   * stores the underlying WebNN MLTensor when location is 'ml-tensor'. otherwise empty.\n   */\n  private mlTensorData?: TensorMLTensorType;\n\n  /**\n   * stores an optional downloader function to download data from GPU to CPU.\n   */\n  private downloader?(): Promise<TensorDataType>;\n\n  /**\n   * a flag indicating whether the data is being downloaded from GPU to CPU.\n   */\n  private isDownloading?: boolean;\n\n  /**\n   * stores an optional disposer function to dispose the underlying data.\n   */\n  private disposer?(): void;\n  // #endregion\n\n  // #region properties\n  get data(): TensorDataType {\n    this.ensureValid();\n    if (!this.cpuData) {\n      throw new Error(\n        'The data is not on CPU. Use `getData()` to download GPU data to CPU, ' +\n          'or use `texture` or `gpuBuffer` property to access the GPU data directly.',\n      );\n    }\n    return this.cpuData;\n  }\n\n  get location(): TensorDataLocation {\n    return this.dataLocation;\n  }\n\n  get texture(): TensorTextureType {\n    this.ensureValid();\n    if (!this.gpuTextureData) {\n      throw new Error('The data is not stored as a WebGL texture.');\n    }\n    return this.gpuTextureData;\n  }\n\n  get gpuBuffer(): TensorGpuBufferType {\n    this.ensureValid();\n    if (!this.gpuBufferData) {\n      throw new Error('The data is not stored as a WebGPU buffer.');\n    }\n    return this.gpuBufferData;\n  }\n\n  get mlTensor(): TensorMLTensorType {\n    this.ensureValid();\n    if (!this.mlTensorData) {\n      throw new Error('The data is not stored as a WebNN MLTensor.');\n    }\n    return this.mlTensorData;\n  }\n  // #endregion\n\n  // #region methods\n\n  async getData(releaseData?: boolean): Promise<TensorDataType> {\n    this.ensureValid();\n    switch (this.dataLocation) {\n      case 'cpu':\n      case 'cpu-pinned':\n        return this.data;\n      case 'texture':\n      case 'gpu-buffer':\n      case 'ml-tensor': {\n        if (!this.downloader) {\n          throw new Error('The current tensor is not created with a specified data downloader.');\n        }\n        if (this.isDownloading) {\n          throw new Error('The current tensor is being downloaded.');\n        }\n        try {\n          this.isDownloading = true;\n          const data = await this.downloader();\n          this.downloader = undefined;\n          this.dataLocation = 'cpu';\n          this.cpuData = data;\n\n          if (releaseData && this.disposer) {\n            this.disposer();\n            this.disposer = undefined;\n          }\n\n          return data;\n        } finally {\n          this.isDownloading = false;\n        }\n      }\n      default:\n        throw new Error(`cannot get data from location: ${this.dataLocation}`);\n    }\n  }\n\n  dispose(): void {\n    if (this.isDownloading) {\n      throw new Error('The current tensor is being downloaded.');\n    }\n\n    if (this.disposer) {\n      this.disposer();\n      this.disposer = undefined;\n    }\n    this.cpuData = undefined;\n    this.gpuTextureData = undefined;\n    this.gpuBufferData = undefined;\n    this.mlTensorData = undefined;\n    this.downloader = undefined;\n    this.isDownloading = undefined;\n\n    this.dataLocation = 'none';\n  }\n\n  // #endregion\n\n  // #region tensor utilities\n  private ensureValid(): void {\n    if (this.dataLocation === 'none') {\n      throw new Error('The tensor is disposed.');\n    }\n  }\n\n  reshape(dims: readonly number[]): TensorInterface {\n    this.ensureValid();\n    if (this.downloader || this.disposer) {\n      throw new Error('Cannot reshape a tensor that owns GPU resource.');\n    }\n    return tensorReshape(this, dims);\n  }\n  // #endregion\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { TensorFactory } from './tensor-factory.js';\nimport { Tensor as TensorImpl } from './tensor-impl.js';\nimport { TypedTensorUtils } from './tensor-utils.js';\nimport { TryGetGlobalType } from './type-helper.js';\n\n/* eslint-disable @typescript-eslint/no-redeclare */\n\n/**\n * represent a basic tensor with specified dimensions and data type.\n */\ninterface TypedTensorBase<T extends Tensor.Type> {\n  /**\n   * Get the dimensions of the tensor.\n   */\n  readonly dims: readonly number[];\n  /**\n   * Get the data type of the tensor.\n   */\n  readonly type: T;\n  /**\n   * Get the buffer data of the tensor.\n   *\n   * If the data is not on CPU (eg. it's in the form of WebGL texture or WebGPU buffer), throw error.\n   */\n  readonly data: Tensor.DataTypeMap[T];\n  /**\n   * Get the location of the data.\n   */\n  readonly location: Tensor.DataLocation;\n  /**\n   * Get the WebGL texture that holds the tensor data.\n   *\n   * If the data is not on GPU as WebGL texture, throw error.\n   */\n  readonly texture: Tensor.TextureType;\n  /**\n   * Get the WebGPU buffer that holds the tensor data.\n   *\n   * If the data is not on GPU as WebGPU buffer, throw error.\n   */\n  readonly gpuBuffer: Tensor.GpuBufferType;\n\n  /**\n   * Get the WebNN MLTensor that holds the tensor data.\n   *\n   * If the data is not in a WebNN MLTensor, throw error.\n   */\n  readonly mlTensor: Tensor.MLTensorType;\n\n  /**\n   * Get the buffer data of the tensor.\n   *\n   * If the data is on CPU, returns the data immediately.\n   * If the data is on GPU, downloads the data and returns the promise.\n   *\n   * @param releaseData - whether release the data on GPU. Ignore if data is already on CPU.\n   */\n  getData(releaseData?: boolean): Promise<Tensor.DataTypeMap[T]>;\n\n  /**\n   * Dispose the tensor data.\n   *\n   * If the data is on CPU, remove its internal reference to the underlying data.\n   * If the data is on GPU, release the data on GPU.\n   *\n   * After calling this function, the tensor is considered no longer valid. Its location will be set to 'none'.\n   */\n  dispose(): void;\n}\n\nexport declare namespace Tensor {\n  interface DataTypeMap {\n    float32: Float32Array;\n    uint8: Uint8Array;\n    int8: Int8Array;\n    uint16: Uint16Array;\n    int16: Int16Array;\n    int32: Int32Array;\n    int64: BigInt64Array;\n    string: string[];\n    bool: Uint8Array;\n    float16: Uint16Array; // Keep using Uint16Array until we have a concrete solution for float 16.\n    float64: Float64Array;\n    uint32: Uint32Array;\n    uint64: BigUint64Array;\n    // complex64: never;\n    // complex128: never;\n    // bfloat16: never;\n    uint4: Uint8Array;\n    int4: Int8Array;\n  }\n\n  interface ElementTypeMap {\n    float32: number;\n    uint8: number;\n    int8: number;\n    uint16: number;\n    int16: number;\n    int32: number;\n    int64: bigint;\n    string: string;\n    bool: boolean;\n    float16: number; // Keep using Uint16Array until we have a concrete solution for float 16.\n    float64: number;\n    uint32: number;\n    uint64: bigint;\n    // complex64: never;\n    // complex128: never;\n    // bfloat16: never;\n    uint4: number;\n    int4: number;\n  }\n\n  type DataType = DataTypeMap[Type];\n  type ElementType = ElementTypeMap[Type];\n\n  /**\n   * supported data types for constructing a tensor from a pinned CPU buffer\n   */\n  export type CpuPinnedDataTypes = Exclude<Tensor.Type, 'string'>;\n\n  /**\n   * type alias for WebGL texture\n   */\n  export type TextureType = WebGLTexture;\n\n  /**\n   * supported data types for constructing a tensor from a WebGL texture\n   */\n  export type TextureDataTypes = 'float32';\n\n  type GpuBufferTypeFallback = { size: number; mapState: 'unmapped' | 'pending' | 'mapped' };\n  /**\n   * type alias for WebGPU buffer\n   */\n  export type GpuBufferType = TryGetGlobalType<'GPUBuffer', GpuBufferTypeFallback>;\n\n  type MLTensorTypeFallback = { destroy(): void };\n  /**\n   * type alias for WebNN MLTensor\n   *\n   * The specification for WebNN's MLTensor is currently in flux.\n   */\n  export type MLTensorType = TryGetGlobalType<'MLTensor', MLTensorTypeFallback>;\n\n  /**\n   * supported data types for constructing a tensor from a WebGPU buffer\n   */\n  export type GpuBufferDataTypes = 'float32' | 'float16' | 'int32' | 'int64' | 'uint32' | 'uint8' | 'bool';\n\n  /**\n   * supported data types for constructing a tensor from a WebNN MLTensor\n   */\n  export type MLTensorDataTypes =\n    | 'float32'\n    | 'float16'\n    | 'int8'\n    | 'uint8'\n    | 'int32'\n    | 'uint32'\n    | 'int64'\n    | 'uint64'\n    | 'bool'\n    | 'uint4'\n    | 'int4';\n\n  /**\n   * represent where the tensor data is stored\n   */\n  export type DataLocation = 'none' | 'cpu' | 'cpu-pinned' | 'texture' | 'gpu-buffer' | 'ml-tensor';\n\n  /**\n   * represent the data type of a tensor\n   */\n  export type Type = keyof DataTypeMap;\n}\n\n/**\n * Represent multi-dimensional arrays to feed to or fetch from model inferencing.\n */\nexport interface TypedTensor<T extends Tensor.Type> extends TypedTensorBase<T>, TypedTensorUtils<T> {}\n/**\n * Represent multi-dimensional arrays to feed to or fetch from model inferencing.\n */\nexport interface Tensor extends TypedTensorBase<Tensor.Type>, TypedTensorUtils<Tensor.Type> {}\n\n/**\n * type TensorConstructor defines the constructors of 'Tensor' to create CPU tensor instances.\n */\nexport interface TensorConstructor extends TensorFactory {\n  // #region CPU tensor - specify element type\n  /**\n   * Construct a new string tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (\n    type: 'string',\n    data: Tensor.DataTypeMap['string'] | readonly string[],\n    dims?: readonly number[],\n  ): TypedTensor<'string'>;\n\n  /**\n   * Construct a new bool tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (\n    type: 'bool',\n    data: Tensor.DataTypeMap['bool'] | readonly boolean[],\n    dims?: readonly number[],\n  ): TypedTensor<'bool'>;\n\n  /**\n   * Construct a new uint8 tensor object from a Uint8ClampedArray, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (type: 'uint8', data: Uint8ClampedArray, dims?: readonly number[]): TypedTensor<'uint8'>;\n\n  /**\n   * Construct a new 64-bit integer typed tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new <T extends 'uint64' | 'int64'>(\n    type: T,\n    data: Tensor.DataTypeMap[T] | readonly bigint[] | readonly number[],\n    dims?: readonly number[],\n  ): TypedTensor<T>;\n\n  /**\n   * Construct a new numeric tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new <T extends Exclude<Tensor.Type, 'string' | 'bool' | 'uint64' | 'int64'>>(\n    type: T,\n    data: Tensor.DataTypeMap[T] | readonly number[],\n    dims?: readonly number[],\n  ): TypedTensor<T>;\n  // #endregion\n\n  // #region CPU tensor - infer element types\n\n  /**\n   * Construct a new float32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Float32Array, dims?: readonly number[]): TypedTensor<'float32'>;\n\n  /**\n   * Construct a new int8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Int8Array, dims?: readonly number[]): TypedTensor<'int8'>;\n\n  /**\n   * Construct a new uint8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Uint8Array, dims?: readonly number[]): TypedTensor<'uint8'>;\n\n  /**\n   * Construct a new uint8 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Uint8ClampedArray, dims?: readonly number[]): TypedTensor<'uint8'>;\n\n  /**\n   * Construct a new uint16 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Uint16Array, dims?: readonly number[]): TypedTensor<'uint16'>;\n\n  /**\n   * Construct a new int16 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Int16Array, dims?: readonly number[]): TypedTensor<'int16'>;\n\n  /**\n   * Construct a new int32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Int32Array, dims?: readonly number[]): TypedTensor<'int32'>;\n\n  /**\n   * Construct a new int64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: BigInt64Array, dims?: readonly number[]): TypedTensor<'int64'>;\n\n  /**\n   * Construct a new string tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: readonly string[], dims?: readonly number[]): TypedTensor<'string'>;\n\n  /**\n   * Construct a new bool tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: readonly boolean[], dims?: readonly number[]): TypedTensor<'bool'>;\n\n  /**\n   * Construct a new float64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Float64Array, dims?: readonly number[]): TypedTensor<'float64'>;\n\n  /**\n   * Construct a new uint32 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Uint32Array, dims?: readonly number[]): TypedTensor<'uint32'>;\n\n  /**\n   * Construct a new uint64 tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: BigUint64Array, dims?: readonly number[]): TypedTensor<'uint64'>;\n\n  // #endregion\n\n  // #region CPU tensor - fall back to non-generic tensor type declaration\n\n  /**\n   * Construct a new tensor object from the given type, data and dims.\n   *\n   * @param type - Specify the element type.\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (\n    type: Tensor.Type,\n    data: Tensor.DataType | readonly number[] | readonly string[] | readonly bigint[] | readonly boolean[],\n    dims?: readonly number[],\n  ): Tensor;\n\n  /**\n   * Construct a new tensor object from the given data and dims.\n   *\n   * @param data - Specify the CPU tensor data.\n   * @param dims - Specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   */\n  new (data: Tensor.DataType, dims?: readonly number[]): Tensor;\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const Tensor = TensorImpl as TensorConstructor;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { env } from './env-impl.js';\n\n/**\n * @ignore\n */\nexport const TRACE = (deviceType: string, label: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  // eslint-disable-next-line no-console\n  console.timeStamp(`${deviceType}::ORT::${label}`);\n};\n\nconst TRACE_FUNC = (msg: string, extraMsg?: string) => {\n  const stack = new Error().stack?.split(/\\r\\n|\\r|\\n/g) || [];\n  let hasTraceFunc = false;\n  for (let i = 0; i < stack.length; i++) {\n    if (hasTraceFunc && !stack[i].includes('TRACE_FUNC')) {\n      let label = `FUNC_${msg}::${stack[i].trim().split(' ')[1]}`;\n      if (extraMsg) {\n        label += `::${extraMsg}`;\n      }\n      TRACE('CPU', label);\n      return;\n    }\n    if (stack[i].includes('TRACE_FUNC')) {\n      hasTraceFunc = true;\n    }\n  }\n};\n\n/**\n * @ignore\n */\nexport const TRACE_FUNC_BEGIN = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  TRACE_FUNC('BEGIN', extraMsg);\n};\n\n/**\n * @ignore\n */\nexport const TRACE_FUNC_END = (extraMsg?: string) => {\n  if (typeof env.trace === 'undefined' ? !env.wasm.trace : !env.trace) {\n    return;\n  }\n  TRACE_FUNC('END', extraMsg);\n};\n\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   * @remark\n   * different from input argument, in output, OnnxValue is optional. If an OnnxValue is present it will be\n   * used as a pre-allocated value by the inference engine; if omitted, inference engine will allocate buffer\n   * internally.\n   */\n  type FetchesType = readonly string[] | NullableOnnxValueMapType;\n\n  /**\n   * A inferencing return type is an object that uses output names as keys and OnnxValue as corresponding values.\n   */\n  type ReturnType = OnnxValueMapType;\n\n  // #endregion\n\n  // #region session options\n\n  /**\n   * A set of configurations for session behavior.\n   */\n  export interface SessionOptions extends OnnxModelOptions {\n    /**\n     * An array of execution provider options.\n     *\n     * An execution provider option can be a string indicating the name of the execution provider,\n     * or an object of corresponding type.\n     */\n    executionProviders?: readonly ExecutionProviderConfig[];\n\n    /**\n     * The intra OP threads number.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native).\n     */\n    intraOpNumThreads?: number;\n\n    /**\n     * The inter OP threads number.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native).\n     */\n    interOpNumThreads?: number;\n\n    /**\n     * The free dimension override.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    freeDimensionOverrides?: { readonly [dimensionName: string]: number };\n\n    /**\n     * The optimization level.\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    graphOptimizationLevel?: 'disabled' | 'basic' | 'extended' | '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     * 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 WebNNExecutionProviderName,\n      Omit<WebNNContextOptions, 'deviceType'>,\n      Required<Pick<WebNNContextOptions, 'deviceType'>> {\n    context: TryGetGlobalType<'MLContext'>;\n  }\n\n  /**\n   * Represents a set of options for WebNN execution provider with MLContext which is created from GPUDevice.\n   *\n   * @see https://www.w3.org/TR/webnn/#dom-ml-createcontext-gpudevice\n   */\n  export interface WebNNOptionsWebGpu extends WebNNExecutionProviderName {\n    context: TryGetGlobalType<'MLContext'>;\n    gpuDevice: TryGetGlobalType<'GPUDevice'>;\n  }\n\n  /**\n   * Options for WebNN execution provider.\n   */\n  export type WebNNExecutionProviderOption =\n    | WebNNOptionsWithoutMLContext\n    | WebNNOptionsWithMLContext\n    | WebNNOptionsWebGpu;\n\n  // #endregion\n\n  export interface QnnExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'qnn';\n    /**\n     * Specify the QNN backend type. E.g., 'cpu' or 'htp'.\n     * Mutually exclusive with `backendPath`.\n     *\n     * @default 'htp'\n     */\n    backendType?: string;\n    /**\n     * Specify a path to the QNN backend library.\n     * Mutually exclusive with `backendType`.\n     */\n    backendPath?: string;\n    /**\n     * Specify whether to enable HTP FP16 precision.\n     *\n     * @default true\n     */\n    enableFp16Precision?: boolean;\n  }\n  export interface CoreMLExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'coreml';\n    /**\n     * The bit flags for CoreML execution provider.\n     *\n     * ```\n     * COREML_FLAG_USE_CPU_ONLY = 0x001\n     * COREML_FLAG_ENABLE_ON_SUBGRAPH = 0x002\n     * COREML_FLAG_ONLY_ENABLE_DEVICE_WITH_ANE = 0x004\n     * COREML_FLAG_ONLY_ALLOW_STATIC_INPUT_SHAPES = 0x008\n     * COREML_FLAG_CREATE_MLPROGRAM = 0x010\n     * COREML_FLAG_USE_CPU_AND_GPU = 0x020\n     * ```\n     *\n     * See include/onnxruntime/core/providers/coreml/coreml_provider_factory.h for more details.\n     *\n     * This flag is available only in ONNXRuntime (Node.js binding).\n     */\n    coreMlFlags?: number;\n    /**\n     * Specify whether to use CPU only in CoreML EP.\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    useCPUOnly?: boolean;\n    useCPUAndGPU?: boolean;\n    /**\n     * Specify whether to enable CoreML EP on subgraph.\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    enableOnSubgraph?: boolean;\n    /**\n     * Specify whether to only enable CoreML EP for Apple devices with ANE (Apple Neural Engine).\n     *\n     * This setting is available only in ONNXRuntime (react-native).\n     */\n    onlyEnableDeviceWithANE?: boolean;\n  }\n  export interface NnapiExecutionProviderOption extends ExecutionProviderOption {\n    readonly name: 'nnapi';\n    useFP16?: boolean;\n    useNCHW?: boolean;\n    cpuDisabled?: boolean;\n    cpuOnly?: boolean;\n  }\n  // #endregion\n\n  // #endregion\n\n  // #region run options\n\n  /**\n   * A set of configurations for inference run behavior\n   */\n  export interface RunOptions {\n    /**\n     * Log severity level. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/common/logging/severity.h\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    logSeverityLevel?: 0 | 1 | 2 | 3 | 4;\n\n    /**\n     * Log verbosity level.\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    logVerbosityLevel?: number;\n\n    /**\n     * Terminate all incomplete OrtRun calls as soon as possible if true\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     */\n    terminate?: boolean;\n\n    /**\n     * A tag for the Run() calls using this\n     *\n     * This setting is available only in ONNXRuntime (Node.js binding and react-native) or WebAssembly backend\n     */\n    tag?: string;\n\n    /**\n     * Set a single run configuration entry. See\n     * https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/\n     * onnxruntime_run_options_config_keys.h\n     *\n     * This setting is available only in WebAssembly backend. Will support Node.js binding and react-native later\n     *\n     * @example\n     *\n     * ```js\n     * extra: {\n     *   memory: {\n     *     enable_memory_arena_shrinkage: \"1\",\n     *   }\n     * }\n     * ```\n     */\n    extra?: Record<string, unknown>;\n  }\n\n  // #endregion\n\n  // #region value metadata\n\n  /**\n   * The common part of the value metadata type for both tensor and non-tensor values.\n   */\n  export interface ValueMetadataBase {\n    /**\n     * The name of the specified input or output.\n     */\n    readonly name: string;\n  }\n\n  /**\n   * Represents the metadata of a non-tensor value.\n   */\n  export interface NonTensorValueMetadata extends ValueMetadataBase {\n    /**\n     * Get a value indicating whether the value is a tensor.\n     */\n    readonly isTensor: false;\n  }\n\n  /**\n   * Represents the metadata of a tensor value.\n   */\n  export interface TensorValueMetadata extends ValueMetadataBase {\n    /**\n     * Get a value indicating whether the value is a tensor.\n     */\n    readonly isTensor: true;\n    /**\n     * Get the data type of the tensor.\n     */\n    readonly type: Tensor.Type;\n    /**\n     * Get the shape of the tensor.\n     *\n     * If the shape is not defined, the value will an empty array. Otherwise, it will be an array representing the shape\n     * of the tensor. Each element in the array can be a number or a string. If the element is a number, it represents\n     * the corresponding dimension size. If the element is a string, it represents a symbolic dimension.\n     */\n    readonly shape: ReadonlyArray<number | string>;\n  }\n\n  /**\n   * Represents the metadata of a value.\n   */\n  export type ValueMetadata = NonTensorValueMetadata | TensorValueMetadata;\n\n  // #endregion\n}\n\n/**\n * Represent a runtime instance of an ONNX model.\n */\nexport interface InferenceSession {\n  // #region run()\n\n  /**\n   * Execute the model asynchronously with the given feeds and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for detail.\n   * @param options - Optional. A set of options that controls the behavior of model inference.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  run(feeds: InferenceSession.FeedsType, options?: InferenceSession.RunOptions): Promise<InferenceSession.ReturnType>;\n\n  /**\n   * Execute the model asynchronously with the given feeds, fetches and options.\n   *\n   * @param feeds - Representation of the model input. See type description of `InferenceSession.InputType` for detail.\n   * @param fetches - Representation of the model output. See type description of `InferenceSession.OutputType` for\n   * detail.\n   * @param options - Optional. A set of options that controls the behavior of model inference.\n   * @returns A promise that resolves to a map, which uses output names as keys and OnnxValue as corresponding values.\n   */\n  run(\n    feeds: InferenceSession.FeedsType,\n    fetches: InferenceSession.FetchesType,\n    options?: InferenceSession.RunOptions,\n  ): Promise<InferenceSession.ReturnType>;\n\n  // #endregion\n\n  // #region release()\n\n  /**\n   * Release the inference session and the underlying resources.\n   */\n  release(): Promise<void>;\n\n  // #endregion\n\n  // #region profiling\n\n  /**\n   * Start profiling.\n   */\n  startProfiling(): void;\n\n  /**\n   * End profiling.\n   */\n  endProfiling(): void;\n\n  // #endregion\n\n  // #region metadata\n\n  /**\n   * Get input names of the loaded model.\n   */\n  readonly inputNames: readonly string[];\n\n  /**\n   * Get output names of the loaded model.\n   */\n  readonly outputNames: readonly string[];\n\n  /**\n   * Get input metadata of the loaded model.\n   */\n  readonly inputMetadata: readonly InferenceSession.ValueMetadata[];\n\n  /**\n   * Get output metadata of the loaded model.\n   */\n  readonly outputMetadata: readonly InferenceSession.ValueMetadata[];\n\n  // #endregion\n}\n\nexport interface InferenceSessionFactory {\n  // #region create()\n\n  /**\n   * Create a new inference session and load model asynchronously from an ONNX model file.\n   *\n   * @param uri - The URI or file path of the model to load.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(uri: string, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from an array bufer.\n   *\n   * @param buffer - An ArrayBuffer representation of an ONNX model.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: ArrayBufferLike, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from segment of an array bufer.\n   *\n   * @param buffer - An ArrayBuffer representation of an ONNX model.\n   * @param byteOffset - The beginning of the specified portion of the array buffer.\n   * @param byteLength - The length in bytes of the array buffer.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(\n    buffer: ArrayBufferLike,\n    byteOffset: number,\n    byteLength?: number,\n    options?: InferenceSession.SessionOptions,\n  ): Promise<InferenceSession>;\n\n  /**\n   * Create a new inference session and load model asynchronously from a Uint8Array.\n   *\n   * @param buffer - A Uint8Array representation of an ONNX model.\n   * @param options - specify configuration for creating a new inference session.\n   * @returns A promise that resolves to an InferenceSession object.\n   */\n  create(buffer: Uint8Array, options?: InferenceSession.SessionOptions): Promise<InferenceSession>;\n\n  // #endregion\n}\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const InferenceSession: InferenceSessionFactory = InferenceSessionImpl;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { OptionsFormat, OptionsNormalizationParameters, OptionsTensorLayout } from './tensor-factory.js';\n\nexport interface TensorToDataUrlOptions extends OptionsTensorLayout, OptionsFormat, OptionsNormalizationParameters {}\n\nexport interface TensorToImageDataOptions extends OptionsTensorLayout, OptionsFormat, OptionsNormalizationParameters {}\n\nexport interface ConversionUtils {\n  /**\n   * creates a DataURL instance from tensor\n   *\n   * @param options - An optional object representing options for creating a DataURL instance from the tensor.\n   *\n   * The following default settings will be applied:\n   * - `format`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * @returns a DataURL string representing the image converted from tensor data\n   */\n  toDataURL(options?: TensorToDataUrlOptions): string;\n\n  /**\n   * creates an ImageData instance from tensor\n   *\n   * @param options - An optional object representing options for creating an ImageData instance from the tensor.\n   *\n   * The following default settings will be applied:\n   * - `format`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * @returns an ImageData instance representing the image converted from tensor data\n   */\n  toImageData(options?: TensorToImageDataOptions): ImageData;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor, TypedTensor } from './tensor.js';\n\nexport type ImageFormat = 'RGB' | 'RGBA' | 'BGR' | 'RBG';\nexport type ImageTensorLayout = 'NHWC' | 'NCHW';\n\n// the following region contains type definitions for constructing tensor from a specific location.\n\n// #region types for constructing a tensor from a specific location\n\n/**\n * represent common properties of the parameter for constructing a tensor from a specific location.\n */\ninterface CommonConstructorParameters<T> extends Pick<Tensor, 'dims'> {\n  /**\n   * Specify the data type of the tensor.\n   */\n  readonly type: T;\n}\n\n/**\n * represent the parameter for constructing a tensor from a GPU resource.\n */\ninterface GpuResourceConstructorParameters<T extends Tensor.Type> {\n  /**\n   * an optional callback function to download data from GPU to CPU.\n   *\n   * If not provided, the tensor treat the GPU data as external resource.\n   */\n  download?(): Promise<Tensor.DataTypeMap[T]>;\n\n  /**\n   * an optional callback function that will be called when the tensor is disposed.\n   *\n   * If not provided, the tensor treat the GPU data as external resource.\n   */\n  dispose?(): void;\n}\n\n/**\n * represent the parameter for constructing a tensor from a pinned CPU buffer\n */\nexport interface CpuPinnedConstructorParameters<T extends Tensor.CpuPinnedDataTypes = Tensor.CpuPinnedDataTypes>\n  extends CommonConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'cpu-pinned'.\n   */\n  readonly location: 'cpu-pinned';\n  /**\n   * Specify the CPU pinned buffer that holds the tensor data.\n   */\n  readonly data: Tensor.DataTypeMap[T];\n}\n\n/**\n * represent the parameter for constructing a tensor from a WebGL texture\n */\nexport interface TextureConstructorParameters<T extends Tensor.TextureDataTypes = Tensor.TextureDataTypes>\n  extends CommonConstructorParameters<T>,\n    GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'texture'.\n   */\n  readonly location: 'texture';\n  /**\n   * Specify the WebGL texture that holds the tensor data.\n   */\n  readonly texture: Tensor.TextureType;\n}\n\n/**\n * represent the parameter for constructing a tensor from a WebGPU buffer\n */\nexport interface GpuBufferConstructorParameters<T extends Tensor.GpuBufferDataTypes = Tensor.GpuBufferDataTypes>\n  extends CommonConstructorParameters<T>,\n    GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'gpu-buffer'.\n   */\n  readonly location: 'gpu-buffer';\n  /**\n   * Specify the WebGPU buffer that holds the tensor data.\n   */\n  readonly gpuBuffer: Tensor.GpuBufferType;\n}\n\nexport interface MLTensorConstructorParameters<T extends Tensor.MLTensorDataTypes = Tensor.MLTensorDataTypes>\n  extends CommonConstructorParameters<T>,\n    GpuResourceConstructorParameters<T> {\n  /**\n   * Specify the location of the data to be 'ml-tensor'.\n   */\n  readonly location: 'ml-tensor';\n\n  /**\n   * Specify the WebNN MLTensor that holds the tensor data.\n   */\n  readonly mlTensor: Tensor.MLTensorType;\n}\n\n// #endregion\n\n// the following region contains type definitions of each individual options.\n// the tensor factory functions use a composition of those options as the parameter type.\n\n// #region Options fields\n\nexport interface OptionsFormat {\n  /**\n   * Describes the image format represented in RGBA color space.\n   */\n  format?: ImageFormat;\n}\n\nexport interface OptionsTensorFormat {\n  /**\n   * Describes the image format of the tensor.\n   *\n   * NOTE: this is different from option 'format'. While option 'format' represents the original image, 'tensorFormat'\n   * represents the target format of the tensor. A transpose will be performed if they are different.\n   */\n  tensorFormat?: ImageFormat;\n}\n\nexport interface OptionsTensorDataType {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: 'float32' | 'uint8';\n}\n\nexport interface OptionsTensorLayout {\n  /**\n   * Describes the tensor layout when representing data of one or more image(s).\n   */\n  tensorLayout?: ImageTensorLayout;\n}\n\nexport interface OptionsDimensions {\n  /**\n   * Describes the image height in pixel\n   */\n  height?: number;\n  /**\n   * Describes the image width in pixel\n   */\n  width?: number;\n}\n\nexport interface OptionResizedDimensions {\n  /**\n   * Describes the resized height. If omitted, original height will be used.\n   */\n  resizedHeight?: number;\n  /**\n   * Describes resized width - can be accessed via tensor dimensions as well\n   */\n  resizedWidth?: number;\n}\n\nexport interface OptionsNormalizationParameters {\n  /**\n   * Describes normalization parameters when preprocessing the image as model input.\n   *\n   * Data element are ranged from 0 to 255.\n   */\n  norm?: {\n    /**\n     * The 'bias' value for image normalization.\n     * - If omitted, use default value 0.\n     * - If it's a single number, apply to each channel\n     * - If it's an array of 3 or 4 numbers, apply element-wise. Number of elements need to match the number of channels\n     * for the corresponding image format\n     */\n    bias?: number | [number, number, number] | [number, number, number, number];\n    /**\n     * The 'mean' value for image normalization.\n     * - If omitted, use default value 255.\n     * - If it's a single number, apply to each channel\n     * - If it's an array of 3 or 4 numbers, apply element-wise. Number of elements need to match the number of channels\n     * for the corresponding image format\n     */\n    mean?: number | [number, number, number] | [number, number, number, number];\n  };\n}\n\n// #endregion\n\n// #region Options composition\n\nexport interface TensorFromImageDataOptions\n  extends OptionResizedDimensions,\n    OptionsTensorFormat,\n    OptionsTensorLayout,\n    OptionsTensorDataType,\n    OptionsNormalizationParameters {}\n\nexport interface TensorFromImageElementOptions\n  extends OptionResizedDimensions,\n    OptionsTensorFormat,\n    OptionsTensorLayout,\n    OptionsTensorDataType,\n    OptionsNormalizationParameters {}\n\nexport interface TensorFromUrlOptions\n  extends OptionsDimensions,\n    OptionResizedDimensions,\n    OptionsTensorFormat,\n    OptionsTensorLayout,\n    OptionsTensorDataType,\n    OptionsNormalizationParameters {}\n\nexport interface TensorFromImageBitmapOptions\n  extends OptionResizedDimensions,\n    OptionsTensorFormat,\n    OptionsTensorLayout,\n    OptionsTensorDataType,\n    OptionsNormalizationParameters {}\n\nexport interface TensorFromTextureOptions<T extends Tensor.TextureDataTypes>\n  extends Required<OptionsDimensions>,\n    OptionsFormat,\n    GpuResourceConstructorParameters<T> /* TODO: add more */ {}\n\nexport interface TensorFromGpuBufferOptions<T extends Tensor.GpuBufferDataTypes>\n  extends Pick<Tensor, 'dims'>,\n    GpuResourceConstructorParameters<T> {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: T;\n}\n\nexport interface TensorFromMLTensorOptions<T extends Tensor.MLTensorDataTypes>\n  extends Pick<Tensor, 'dims'>,\n    GpuResourceConstructorParameters<T> {\n  /**\n   * Describes the data type of the tensor.\n   */\n  dataType?: T;\n}\n\n// #endregion\n\n/**\n * type TensorFactory defines the factory functions of 'Tensor' to create tensor instances from existing data or\n * resources.\n */\nexport interface TensorFactory {\n  /**\n   * create a tensor from an ImageData object\n   *\n   * @param imageData - the ImageData object to create tensor from\n   * @param options - An optional object representing options for creating tensor from ImageData.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(\n    imageData: ImageData,\n    options?: TensorFromImageDataOptions,\n  ): Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from a HTMLImageElement object\n   *\n   * @param imageElement - the HTMLImageElement object to create tensor from\n   * @param options - An optional object representing options for creating tensor from HTMLImageElement.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(\n    imageElement: HTMLImageElement,\n    options?: TensorFromImageElementOptions,\n  ): Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from URL\n   *\n   * @param urlSource - a string as a URL to the image or a data URL containing the image data.\n   * @param options - An optional object representing options for creating tensor from URL.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(urlSource: string, options?: TensorFromUrlOptions): Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from an ImageBitmap object\n   *\n   * @param bitmap - the ImageBitmap object to create tensor from\n   * @param options - An optional object representing options for creating tensor from URL.\n   *\n   * The following default settings will be applied:\n   * - `tensorFormat`: `'RGB'`\n   * - `tensorLayout`: `'NCHW'`\n   * - `dataType`: `'float32'`\n   * @returns A promise that resolves to a tensor object\n   */\n  fromImage(\n    bitmap: ImageBitmap,\n    options: TensorFromImageBitmapOptions,\n  ): Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n\n  /**\n   * create a tensor from a WebGL texture\n   *\n   * @param texture - the WebGLTexture object to create tensor from\n   * @param options - An optional object representing options for creating tensor from WebGL texture.\n   *\n   * The options include following properties:\n   * - `width`: the width of the texture. Required.\n   * - `height`: the height of the texture. Required.\n   * - `format`: the format of the texture. If omitted, assume 'RGBA'.\n   * - `download`: an optional function to download the tensor data from GPU to CPU. If omitted, the GPU data\n   * will not be able to download. Usually, this is provided by a GPU backend for the inference outputs. Users don't\n   * need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on GPU. If omitted, the GPU data will not be disposed.\n   * Usually, this is provided by a GPU backend for the inference outputs. Users don't need to provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromTexture<T extends Tensor.TextureDataTypes = 'float32'>(\n    texture: Tensor.TextureType,\n    options: TensorFromTextureOptions<T>,\n  ): TypedTensor<'float32'>;\n\n  /**\n   * create a tensor from a WebGPU buffer\n   *\n   * @param buffer - the GPUBuffer object to create tensor from\n   * @param options - An optional object representing options for creating tensor from WebGPU buffer.\n   *\n   * The options include following properties:\n   * - `dataType`: the data type of the tensor. If omitted, assume 'float32'.\n   * - `dims`: the dimension of the tensor. Required.\n   * - `download`: an optional function to download the tensor data from GPU to CPU. If omitted, the GPU data\n   * will not be able to download. Usually, this is provided by a GPU backend for the inference outputs. Users don't\n   * need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on GPU. If omitted, the GPU data will not be disposed.\n   * Usually, this is provided by a GPU backend for the inference outputs. Users don't need to provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromGpuBuffer<T extends Tensor.GpuBufferDataTypes>(\n    buffer: Tensor.GpuBufferType,\n    options: TensorFromGpuBufferOptions<T>,\n  ): TypedTensor<T>;\n\n  /**\n   * create a tensor from a WebNN MLTensor\n   *\n   * @param tensor - the MLTensor object to create tensor from\n   * @param options - An optional object representing options for creating tensor from a WebNN MLTensor.\n   *\n   * The options include following properties:\n   * - `dataType`: the data type of the tensor. If omitted, assume 'float32'.\n   * - `dims`: the dimension of the tensor. Required.\n   * - `download`: an optional function to download the tensor data from the MLTensor to CPU. If omitted, the MLTensor\n   * data will not be able to download. Usually, this is provided by the WebNN backend for the inference outputs.\n   * Users don't need to provide this function.\n   * - `dispose`: an optional function to dispose the tensor data on the WebNN MLTensor. If omitted, the MLTensor will\n   * not be disposed. Usually, this is provided by the WebNN backend for the inference outputs. Users don't need to\n   * provide this function.\n   *\n   * @returns a tensor object\n   */\n  fromMLTensor<T extends Tensor.MLTensorDataTypes>(\n    tensor: Tensor.MLTensorType,\n    options: TensorFromMLTensorOptions<T>,\n  ): TypedTensor<T>;\n\n  /**\n   * create a tensor from a pre-allocated buffer. The buffer will be used as a pinned buffer.\n   *\n   * @param type - the tensor element type.\n   * @param buffer - a TypedArray corresponding to the type.\n   * @param dims - specify the dimension of the tensor. If omitted, a 1-D tensor is assumed.\n   *\n   * @returns a tensor object\n   */\n  fromPinnedBuffer<T extends Exclude<Tensor.Type, 'string'>>(\n    type: T,\n    buffer: Tensor.DataTypeMap[T],\n    dims?: readonly number[],\n  ): TypedTensor<T>;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/**\n * A string that represents a file's URL or path.\n *\n * Path is vailable only in onnxruntime-node or onnxruntime-web running in Node.js.\n */\nexport type FileUrlOrPath = string;\n\n/**\n * A Blob object that represents a file.\n */\nexport type FileBlob = Blob;\n\n/**\n * A Uint8Array, ArrayBuffer or SharedArrayBuffer object that represents a file content.\n *\n * When it is an ArrayBuffer or SharedArrayBuffer, the whole buffer is assumed to be the file content.\n */\nexport type FileData = Uint8Array | ArrayBufferLike;\n\n/**\n * Represents a file that can be loaded by the ONNX Runtime JavaScript API.\n */\nexport type FileType = FileUrlOrPath | FileBlob | FileData;\n\n/**\n * Represents an external data file.\n */\nexport interface ExternalDataFileDescription {\n  /**\n   * Specify the external data file.\n   */\n  data: FileType;\n  /**\n   * Specify the file path.\n   */\n  path: string;\n}\n\n/**\n * Represents an external data file.\n *\n * When using a string, it should be a file URL or path that in the same directory as the model file.\n */\nexport type ExternalDataFileType = ExternalDataFileDescription | FileUrlOrPath;\n\n/**\n * Options for model loading.\n */\nexport interface OnnxModelOptions {\n  /**\n   * Specifying a list of files that represents the external data.\n   */\n  externalData?: readonly ExternalDataFileType[];\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from './tensor.js';\n\nexport type NonTensorType = never;\n\n/**\n * Type OnnxValue Represents both tensors and non-tensors value for model's inputs/outputs.\n *\n * NOTE: currently not support non-tensor\n */\nexport type OnnxValue = Tensor | NonTensorType;\n\n/**\n * Type OnnxValueDataLocation represents the location of the data of an OnnxValue.\n */\nexport type OnnxValueDataLocation = Tensor.DataLocation;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/**\n * # ONNX Runtime JavaScript API\n *\n * ONNX Runtime JavaScript API is a unified API for all JavaScript usages, including the following NPM packages:\n *\n * - [onnxruntime-node](https://www.npmjs.com/package/onnxruntime-node)\n * - [onnxruntime-web](https://www.npmjs.com/package/onnxruntime-web)\n * - [onnxruntime-react-native](https://www.npmjs.com/package/onnxruntime-react-native)\n *\n * See also:\n * - [Get Started](https://onnxruntime.ai/docs/get-started/with-javascript/)\n * - [Inference examples](https://github.com/microsoft/onnxruntime-inference-examples/tree/main/js)\n *\n * @packageDocumentation\n */\n\nexport * from './backend.js';\nexport * from './env.js';\nexport * from './inference-session.js';\nexport * from './tensor.js';\nexport * from './tensor-conversion.js';\nexport * from './tensor-factory.js';\nexport * from './trace.js';\nexport * from './onnx-model.js';\nexport * from './onnx-value.js';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nexport const isNode = !!(typeof process !== 'undefined' && process.versions && process.versions.node);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/// <reference lib=\"webworker\" />\n\n//\n// * type hack for \"HTMLImageElement\"\n//\n// in typescript, the type of \"HTMLImageElement\" is defined in lib.dom.d.ts, which is conflict with lib.webworker.d.ts.\n// when we use webworker, the lib.webworker.d.ts will be used, which does not have HTMLImageElement defined.\n//\n// we will get the following errors complaining that HTMLImageElement is not defined:\n//\n// ====================================================================================================================\n//\n// ../common/dist/cjs/tensor-factory.d.ts:187:29 - error TS2552: Cannot find name 'HTMLImageElement'. Did you mean\n// 'HTMLLIElement'?\n//\n// 187     fromImage(imageElement: HTMLImageElement, options?: TensorFromImageElementOptions):\n// Promise<TypedTensor<'float32'> | TypedTensor<'uint8'>>;\n//                                 ~~~~~~~~~~~~~~~~\n//\n// node_modules/@webgpu/types/dist/index.d.ts:83:7 - error TS2552: Cannot find name 'HTMLImageElement'. Did you mean\n// 'HTMLLIElement'?\n//\n// 83     | HTMLImageElement\n//          ~~~~~~~~~~~~~~~~\n//\n// ====================================================================================================================\n//\n// `HTMLImageElement` is only used in type declaration and not in real code. So we define it as `unknown` here to\n// bypass the type check.\n\n//\n// * type hack for \"document\"\n//\n// in typescript, the type of \"document\" is defined in lib.dom.d.ts, so it's not available in webworker.\n//\n// we will get the following errors complaining that document is not defined:\n//\n// ====================================================================================================================\n//\n// lib/wasm/wasm-utils-import.ts:7:33 - error TS2584: Cannot find name 'document'. Do you need to change your target\n// library? Try changing the 'lib' compiler option to include 'dom'.\n//\n// 7 export const scriptSrc = typeof document !== 'undefined' ? (document?.currentScript as HTMLScriptElement)?.src :\n//                                   ~~~~~~~~\n//\n// lib/wasm/wasm-utils-import.ts:7:61 - error TS2584: Cannot find name 'document'. Do you need to change your target\n// library? Try changing the 'lib' compiler option to include 'dom'.\n//\n// 7 export const scriptSrc = typeof document !== 'undefined' ? (document?.currentScript as HTMLScriptElement)?.src :\n//                                                               ~~~~~~~~\n//\n// lib/wasm/wasm-utils-import.ts:7:88 - error TS2552: Cannot find name 'HTMLScriptElement'. Did you mean\n// 'HTMLLIElement'?\n//\n// 7 export const scriptSrc = typeof document !== 'undefined' ? (document?.currentScript as HTMLScriptElement)?.src :\n//                                                                                          ~~~~~~~~~~~~~~~~~\n// ====================================================================================================================\n//\n// `document` is used to get the current script URL, which is not available in webworker. This file is served as a\n// \"dual\" file for entries of both webworker and the esm module.\n//\ndeclare global {\n  type HTMLImageElement = unknown;\n  type HTMLScriptElement = { src?: string };\n  const document: undefined | { currentScript?: HTMLScriptElement };\n}\n\n/**\n * @summary\n *\n * This file is served as a \"dual\" file for both entries of the following:\n * - The proxy worker itself.\n *   - When used as a worker, it listens to the messages from the main thread and performs the corresponding operations.\n *   - Should be imported directly using `new Worker()` in the main thread.\n *\n * - The ESM module that creates the proxy worker (as a worker launcher).\n *   - When used as a worker launcher, it creates the proxy worker and returns it.\n *   - Should be imported using `import()` in the main thread, with the query parameter `import=1`.\n *\n * This file will be always compiling into ESM format.\n */\n\nimport type { OrtWasmMessage, SerializableTensorMetadata } from '../proxy-messages.js';\nimport {\n  createSession,\n  copyFromExternalBuffer,\n  endProfiling,\n  extractTransferableBuffers,\n  initEp,\n  initRuntime,\n  releaseSession,\n  run,\n} from '../wasm-core-impl.js';\nimport { initializeWebAssembly } from '../wasm-factory.js';\nimport { scriptSrc } from '../wasm-utils-import.js';\n\nconst WORKER_NAME = 'ort-wasm-proxy-worker';\nconst isProxyWorker = globalThis.self?.name === WORKER_NAME;\n\nif (isProxyWorker) {\n  // Worker thread\n  self.onmessage = (ev: MessageEvent<OrtWasmMessage>): void => {\n    const { type, in: message } = ev.data;\n    try {\n      switch (type) {\n        case 'init-wasm':\n          initializeWebAssembly(message!.wasm).then(\n            () => {\n              initRuntime(message!).then(\n                () => {\n                  postMessage({ type });\n                },\n                (err) => {\n                  postMessage({ type, err });\n                },\n              );\n            },\n            (err) => {\n              postMessage({ type, err });\n            },\n          );\n          break;\n        case 'init-ep': {\n          const { epName, env } = message!;\n          initEp(env, epName).then(\n            () => {\n              postMessage({ type });\n            },\n            (err) => {\n              postMessage({ type, err });\n            },\n          );\n          break;\n        }\n        case 'copy-from': {\n          const { buffer } = message!;\n          const bufferData = copyFromExternalBuffer(buffer);\n          postMessage({ type, out: bufferData } as OrtWasmMessage);\n          break;\n        }\n        case 'create': {\n          const { model, options } = message!;\n          createSession(model, options).then(\n            (sessionMetadata) => {\n              postMessage({ type, out: sessionMetadata } as OrtWasmMessage);\n            },\n            (err) => {\n              postMessage({ type, err });\n            },\n          );\n          break;\n        }\n        case 'release':\n          releaseSession(message!);\n          postMessage({ type });\n          break;\n        case 'run': {\n          const { sessionId, inputIndices, inputs, outputIndices, options } = message!;\n          run(sessionId, inputIndices, inputs, outputIndices, new Array(outputIndices.length).fill(null), options).then(\n            (outputs) => {\n              if (outputs.some((o) => o[3] !== 'cpu')) {\n                postMessage({ type, err: 'Proxy does not support non-cpu tensor location.' });\n              } else {\n                postMessage(\n                  { type, out: outputs } as OrtWasmMessage,\n                  extractTransferableBuffers([...inputs, ...outputs] as SerializableTensorMetadata[]),\n                );\n              }\n            },\n            (err) => {\n              postMessage({ type, err });\n            },\n          );\n          break;\n        }\n        case 'end-profiling':\n          endProfiling(message!);\n          postMessage({ type });\n          break;\n        default:\n      }\n    } catch (err) {\n      postMessage({ type, err } as OrtWasmMessage);\n    }\n  };\n}\n\nexport default isProxyWorker\n  ? null\n  : (urlOverride?: string) =>\n      new Worker(urlOverride ?? scriptSrc!, { type: BUILD_DEFS.IS_ESM ? 'module' : 'classic', name: WORKER_NAME });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport type { OrtWasmModule } from './wasm-types';\nimport { isNode } from './wasm-utils-env';\n\n/**\n * The origin of the current location.\n *\n * In Node.js, this is undefined.\n */\nconst origin = isNode || typeof location === 'undefined' ? undefined : location.origin;\n\n/**\n * Some bundlers (eg. Webpack) will rewrite `import.meta.url` to a file URL at compile time.\n *\n * This function checks if `import.meta.url` starts with `file:`, but using the `>` and `<` operators instead of\n * `startsWith` function so that code minimizers can remove the dead code correctly.\n *\n * For example, if we use terser to minify the following code:\n * ```js\n * if (\"file://hard-coded-filename\".startsWith(\"file:\")) {\n *   console.log(1)\n * } else {\n *   console.log(2)\n * }\n *\n * if (\"file://hard-coded-filename\" > \"file:\" && \"file://hard-coded-filename\" < \"file;\") {\n *   console.log(3)\n * } else {\n *   console.log(4)\n * }\n * ```\n *\n * The minified code will be:\n * ```js\n * \"file://hard-coded-filename\".startsWith(\"file:\")?console.log(1):console.log(2),console.log(3);\n * ```\n *\n * (use Terser 5.39.0 with default options, https://try.terser.org/)\n *\n * @returns true if the import.meta.url is hardcoded as a file URI.\n */\nexport const isEsmImportMetaUrlHardcodedAsFileUri =\n  BUILD_DEFS.IS_ESM && BUILD_DEFS.ESM_IMPORT_META_URL! > 'file:' && BUILD_DEFS.ESM_IMPORT_META_URL! < 'file;';\n\nconst getScriptSrc = (): string | undefined => {\n  // if Nodejs, return undefined\n  if (isNode) {\n    return undefined;\n  }\n  // if It's ESM, use import.meta.url\n  if (BUILD_DEFS.IS_ESM) {\n    // For ESM, if the import.meta.url is a file URL, this usually means the bundler rewrites `import.meta.url` to\n    // the file path at compile time. In this case, this file path cannot be used to determine the runtime URL.\n    //\n    // We need to use the URL constructor like this:\n    // ```js\n    // new URL('actual-bundle-name.js', import.meta.url).href\n    // ```\n    // So that bundler can preprocess the URL correctly.\n    if (isEsmImportMetaUrlHardcodedAsFileUri) {\n      // if the rewritten URL is a relative path, we need to use the origin to resolve the URL.\n\n      // The following is a workaround for Vite.\n      //\n      // Vite uses a bundler(rollup/rolldown) that does not rewrite `import.meta.url` to a file URL. So in theory, this\n      // code path should not be executed in Vite. However, the bundler does not know it and it still try to load the\n      // following pattern:\n      // - `return new URL('filename', import.meta.url).href`\n      //\n      // By replacing the pattern above with the following code, we can skip the resource loading behavior:\n      // - `const URL2 = URL; return new URL2('filename', import.meta.url).href;`\n      //\n      // And it still works in Webpack.\n      const URL2 = URL;\n      return new URL(new URL2(BUILD_DEFS.BUNDLE_FILENAME, BUILD_DEFS.ESM_IMPORT_META_URL).href, origin).href;\n    }\n\n    return BUILD_DEFS.ESM_IMPORT_META_URL;\n  }\n\n  return typeof document !== 'undefined'\n    ? (document.currentScript as HTMLScriptElement)?.src\n    : // use `self.location.href` if available\n      typeof self !== 'undefined'\n      ? self.location?.href\n      : undefined;\n};\n\n/**\n * The classic script source URL. This is not always available in non ESModule environments.\n *\n * In Node.js, this is undefined.\n */\nexport const scriptSrc = getScriptSrc();\n\n/**\n * Infer the wasm path prefix from the script source URL.\n *\n * @returns The inferred wasm path prefix, or undefined if the script source URL is not available or is a blob URL.\n */\nexport const inferWasmPathPrefixFromScriptSrc = (): string | undefined => {\n  if (scriptSrc && !scriptSrc.startsWith('blob:')) {\n    return scriptSrc.substring(0, scriptSrc.lastIndexOf('/') + 1);\n  }\n  return undefined;\n};\n\n/**\n * Check if the given filename with prefix is from the same origin.\n */\nconst isSameOrigin = (filename: string, prefixOverride?: string) => {\n  try {\n    const baseUrl = prefixOverride ?? scriptSrc;\n    const url = baseUrl ? new URL(filename, baseUrl) : new URL(filename);\n    return url.origin === origin;\n  } catch {\n    return false;\n  }\n};\n\n/**\n * Normalize the inputs to an absolute URL with the given prefix override. If failed, return undefined.\n */\nconst normalizeUrl = (filename: string, prefixOverride?: string) => {\n  const baseUrl = prefixOverride ?? scriptSrc;\n  try {\n    const url = baseUrl ? new URL(filename, baseUrl) : new URL(filename);\n    return url.href;\n  } catch {\n    return undefined;\n  }\n};\n\n/**\n * Create a fallback URL if an absolute URL cannot be created by the normalizeUrl function.\n */\nconst fallbackUrl = (filename: string, prefixOverride?: string) => `${prefixOverride ?? './'}${filename}`;\n\n/**\n * This helper function is used to preload a module from a URL.\n *\n * If the origin of the worker URL is different from the current origin, the worker cannot be loaded directly.\n * See discussions in https://github.com/webpack-contrib/worker-loader/issues/154\n *\n * In this case, we will fetch the worker URL and create a new Blob URL with the same origin as a workaround.\n *\n * @param absoluteUrl - The absolute URL to preload.\n *\n * @returns - A promise that resolves to a new Blob URL\n */\nconst preload = async (absoluteUrl: string): Promise<string> => {\n  const response = await fetch(absoluteUrl, { credentials: 'same-origin' });\n  const blob = await response.blob();\n  return URL.createObjectURL(blob);\n};\n\n/**\n * This helper function is used to dynamically import a module from a URL.\n *\n * The build script has special handling for this function to ensure that the URL is not bundled into the final output.\n *\n * @param url - The URL to import.\n *\n * @returns - A promise that resolves to the default export of the module.\n */\nconst dynamicImportDefault = async <T>(url: string): Promise<T> =>\n  (await import(/* webpackIgnore: true */ /* @vite-ignore */ url)).default;\n\n/**\n * The proxy worker factory imported from the proxy worker module.\n *\n * This is only available when the WebAssembly proxy is not disabled.\n */\nconst createProxyWorker: ((urlOverride?: string) => Worker) | undefined =\n  // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n  BUILD_DEFS.DISABLE_WASM_PROXY ? undefined : require('./proxy-worker/main').default;\n\n/**\n * Import the proxy worker.\n *\n * This function will perform the following steps:\n * 1. If a preload is needed, it will preload the module and return the object URL.\n * 2. Use the proxy worker factory to create the proxy worker.\n *\n * @returns - A promise that resolves to a tuple of 2 elements:\n *            - The object URL of the preloaded module, or undefined if no preload is needed.\n *            - The proxy worker.\n */\nexport const importProxyWorker = async (): Promise<[undefined | string, Worker]> => {\n  if (!scriptSrc) {\n    throw new Error('Failed to load proxy worker: cannot determine the script source URL.');\n  }\n\n  // If the script source is from the same origin, we can use the embedded proxy module directly.\n  if (isSameOrigin(scriptSrc)) {\n    return [undefined, createProxyWorker!()];\n  }\n\n  // Otherwise, need to preload\n  const url = await preload(scriptSrc);\n  return [url, createProxyWorker!(url)];\n};\n\n/**\n * The embedded WebAssembly module.\n *\n * This is only available in ESM and when embedding is not disabled.\n */\nconst embeddedWasmModule: EmscriptenModuleFactory<OrtWasmModule> | undefined =\n  BUILD_DEFS.IS_ESM && BUILD_DEFS.ENABLE_BUNDLE_WASM_JS\n    ? // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n      require(\n        !BUILD_DEFS.DISABLE_JSEP\n          ? '../../dist/ort-wasm-simd-threaded.jsep.mjs'\n          : BUILD_DEFS.ENABLE_JSPI\n            ? '../../dist/ort-wasm-simd-threaded.jspi.mjs'\n            : !BUILD_DEFS.DISABLE_WEBGPU\n              ? '../../dist/ort-wasm-simd-threaded.asyncify.mjs'\n              : '../../dist/ort-wasm-simd-threaded.mjs',\n      ).default\n    : undefined;\n\n/**\n * Import the WebAssembly module.\n *\n * This function will perform the following steps:\n * 1. If the embedded module exists and no custom URL is specified, use the embedded module.\n * 2. If a preload is needed, it will preload the module and return the object URL.\n * 3. Otherwise, it will perform a dynamic import of the module.\n *\n * @returns - A promise that resolves to a tuple of 2 elements:\n *            - The object URL of the preloaded module, or undefined if no preload is needed.\n *            - The default export of the module, which is a factory function to create the WebAssembly module.\n */\nexport const importWasmModule = async (\n  urlOverride: string | undefined,\n  prefixOverride: string | undefined,\n  isMultiThreaded: boolean,\n  isWasmOverridden: boolean,\n): Promise<[undefined | string, EmscriptenModuleFactory<OrtWasmModule>]> => {\n  //\n  // Check if we should use the embedded module.\n  //\n\n  // To use the embedded module, it should be available, and no URL override or prefix override should be specified.\n  let useEmbeddedModule = embeddedWasmModule && !(urlOverride || prefixOverride);\n  if (useEmbeddedModule) {\n    if (!scriptSrc) {\n      // no URL info available.\n      //\n      // Note: when the embedded module is available, it means the current script is ESM. Usually, in ESM, the\n      // `import.meta.url` is available. But in some cases (eg. Cloudflare Workers), the value of `import.meta.url`\n      // can be `null` or `undefined`. In this case, we can only load the embedded module when:\n      //\n      // 1. The WebAssembly module binary is overridden:\n      //    ```js\n      //    env.wasm.wasmPaths = undefined;  // or not specified\n      //    env.wasm.wasmBinary = /* a Uint8Array containing the WebAssembly binary */;\n      //    ```\n      //\n      // 2. The \".wasm\" only is overridden.\n      //    ```js\n      //    env.wasm.wasmPaths = { wasm: /* URL of the .wasm file */ };\n      //    ```\n      //\n      if (isWasmOverridden && !isMultiThreaded) {\n        useEmbeddedModule = true;\n      } else {\n        throw new Error('cannot determine the script source URL.');\n      }\n    } else {\n      // if the script source is available, we can check if it is from the same origin.\n      // Also use the embedded module when wasmBinary is provided and single-threaded (eg. Blob URL workers\n      // where isSameOrigin fails but no file resolution or worker spawning is needed).\n      useEmbeddedModule = isSameOrigin(scriptSrc) || (isWasmOverridden && !isMultiThreaded);\n    }\n  }\n  if (useEmbeddedModule) {\n    return [undefined, embeddedWasmModule!];\n  } else {\n    const wasmModuleFilename = !BUILD_DEFS.DISABLE_JSEP\n      ? 'ort-wasm-simd-threaded.jsep.mjs'\n      : BUILD_DEFS.ENABLE_JSPI\n        ? 'ort-wasm-simd-threaded.jspi.mjs'\n        : !BUILD_DEFS.DISABLE_WEBGPU\n          ? 'ort-wasm-simd-threaded.asyncify.mjs'\n          : 'ort-wasm-simd-threaded.mjs';\n    const wasmModuleUrl = urlOverride ?? normalizeUrl(wasmModuleFilename, prefixOverride);\n    // need to preload if all of the following conditions are met:\n    // 1. not in Node.js.\n    //    - Node.js does not have the same origin policy for creating workers.\n    // 2. multi-threaded is enabled.\n    //    - If multi-threaded is disabled, no worker will be created. So we don't need to preload the module.\n    // 3. the absolute URL is available.\n    //    - If the absolute URL is failed to be created, the origin cannot be determined. In this case, we will not\n    //    preload the module.\n    // 4. the worker URL is not from the same origin.\n    //    - If the worker URL is from the same origin, we can create the worker directly.\n    const needPreload = !isNode && isMultiThreaded && wasmModuleUrl && !isSameOrigin(wasmModuleUrl, prefixOverride);\n    const url = needPreload\n      ? await preload(wasmModuleUrl)\n      : (wasmModuleUrl ?? fallbackUrl(wasmModuleFilename, prefixOverride));\n    return [needPreload ? url : undefined, await dynamicImportDefault<EmscriptenModuleFactory<OrtWasmModule>>(url)];\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Env } from 'onnxruntime-common';\n\nimport type { OrtWasmModule } from './wasm-types';\nimport { importWasmModule, inferWasmPathPrefixFromScriptSrc } from './wasm-utils-import';\n\nlet wasm: OrtWasmModule | undefined;\nlet initialized = false;\nlet initializing = false;\nlet aborted = false;\n\nconst isMultiThreadSupported = (): boolean => {\n  // If 'SharedArrayBuffer' is not available, WebAssembly threads will not work.\n  if (typeof SharedArrayBuffer === 'undefined') {\n    return false;\n  }\n\n  try {\n    // Test for transferability of SABs (for browsers. needed for Firefox)\n    // https://groups.google.com/forum/#!msg/mozilla.dev.platform/IHkBZlHETpA/dwsMNchWEQAJ\n    if (typeof MessageChannel !== 'undefined') {\n      new MessageChannel().port1.postMessage(new SharedArrayBuffer(1));\n    }\n\n    // Test for WebAssembly threads capability (for both browsers and Node.js)\n    // This typed array is a WebAssembly program containing threaded instructions.\n    return WebAssembly.validate(\n      new Uint8Array([\n        0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 4, 1, 3, 1, 1, 10, 11, 1, 9, 0, 65, 0, 254, 16,\n        2, 0, 26, 11,\n      ]),\n    );\n  } catch {\n    return false;\n  }\n};\n\nconst isSimdSupported = (): boolean => {\n  try {\n    // Test for WebAssembly SIMD capability (for both browsers and Node.js)\n    // This typed array is a WebAssembly program containing SIMD instructions.\n\n    // The binary data is generated from the following code by wat2wasm:\n    //\n    // (module\n    //   (type $t0 (func))\n    //   (func $f0 (type $t0)\n    //     (drop\n    //       (i32x4.dot_i16x8_s\n    //         (i8x16.splat\n    //           (i32.const 0))\n    //         (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)))))\n\n    return WebAssembly.validate(\n      new Uint8Array([\n        0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 30, 1, 28, 0, 65, 0, 253, 15, 253, 12, 0, 0, 0,\n        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 253, 186, 1, 26, 11,\n      ]),\n    );\n  } catch {\n    return false;\n  }\n};\n\nconst isRelaxedSimdSupported = (): boolean => {\n  try {\n    // Test for WebAssembly Relaxed SIMD capability (for both browsers and Node.js)\n    // This typed array is a WebAssembly program containing Relaxed SIMD instructions.\n\n    // The binary data is generated from the following code by wat2wasm:\n    // (module\n    //   (func (result v128)\n    //      i32.const 1\n    //      i8x16.splat\n    //      i32.const 2\n    //      i8x16.splat\n    //      i32.const 3\n    //      i8x16.splat\n    //      i32x4.relaxed_dot_i8x16_i7x16_add_s\n    //   )\n    //  )\n    return WebAssembly.validate(\n      new Uint8Array([\n        0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 123, 3, 2, 1, 0, 10, 19, 1, 17, 0, 65, 1, 253, 15, 65, 2, 253,\n        15, 65, 3, 253, 15, 253, 147, 2, 11,\n      ]),\n    );\n  } catch {\n    return false;\n  }\n};\n\nexport const initializeWebAssembly = async (flags: Env.WebAssemblyFlags): Promise<void> => {\n  if (initialized) {\n    return Promise.resolve();\n  }\n  if (initializing) {\n    throw new Error(\"multiple calls to 'initializeWebAssembly()' detected.\");\n  }\n  if (aborted) {\n    throw new Error(\"previous call to 'initializeWebAssembly()' failed.\");\n  }\n\n  initializing = true;\n\n  // wasm flags are already initialized\n  const timeout = flags.initTimeout!;\n  let numThreads = flags.numThreads!;\n\n  // ensure SIMD is supported\n  if (flags.simd === false) {\n    // skip SIMD feature checking as it is disabled explicitly by user\n  } else if (flags.simd === 'relaxed') {\n    // check if relaxed SIMD is supported\n    if (!isRelaxedSimdSupported()) {\n      throw new Error('Relaxed WebAssembly SIMD is not supported in the current environment.');\n    }\n  } else if (!isSimdSupported()) {\n    throw new Error('WebAssembly SIMD is not supported in the current environment.');\n  }\n\n  if (BUILD_DEFS.ENABLE_JSPI) {\n    if (!('Suspending' in WebAssembly)) {\n      throw new Error('WebAssembly JSPI is not supported in the current environment.');\n    }\n  }\n\n  // check if multi-threading is supported\n  const multiThreadSupported = isMultiThreadSupported();\n  if (numThreads > 1 && !multiThreadSupported) {\n    if (typeof self !== 'undefined' && !self.crossOriginIsolated) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        'env.wasm.numThreads is set to ' +\n          numThreads +\n          ', but this will not work unless you enable crossOriginIsolated mode. ' +\n          'See https://web.dev/cross-origin-isolation-guide/ for more info.',\n      );\n    }\n\n    // eslint-disable-next-line no-console\n    console.warn(\n      'WebAssembly multi-threading is not supported in the current environment. ' + 'Falling back to single-threading.',\n    );\n\n    // set flags.numThreads to 1 so that OrtInit() will not create a global thread pool.\n    flags.numThreads = numThreads = 1;\n  }\n\n  const wasmPaths = flags.wasmPaths;\n  const wasmPrefixOverride = typeof wasmPaths === 'string' ? wasmPaths : undefined;\n  const mjsPathOverrideFlag = (wasmPaths as Env.WasmFilePaths)?.mjs;\n  const mjsPathOverride = (mjsPathOverrideFlag as URL)?.href ?? mjsPathOverrideFlag;\n  const wasmPathOverrideFlag = (wasmPaths as Env.WasmFilePaths)?.wasm;\n  const wasmPathOverride = (wasmPathOverrideFlag as URL)?.href ?? wasmPathOverrideFlag;\n  const wasmBinaryOverride = flags.wasmBinary;\n\n  const [objectUrl, ortWasmFactory] = await importWasmModule(\n    mjsPathOverride,\n    wasmPrefixOverride,\n    numThreads > 1,\n    !!wasmBinaryOverride || !!wasmPathOverride,\n  );\n\n  let isTimeout = false;\n\n  const tasks: Array<Promise<void>> = [];\n\n  // promise for timeout\n  if (timeout > 0) {\n    tasks.push(\n      new Promise((resolve) => {\n        setTimeout(() => {\n          isTimeout = true;\n          resolve();\n        }, timeout);\n      }),\n    );\n  }\n\n  // promise for module initialization\n  tasks.push(\n    new Promise((resolve, reject) => {\n      const config: Partial<OrtWasmModule> = {\n        /**\n         * The number of threads. WebAssembly will create (Module.numThreads - 1) workers. If it is 1, no worker will be\n         * created.\n         */\n        numThreads,\n      };\n\n      if (wasmBinaryOverride) {\n        // Set a custom buffer which contains the WebAssembly binary. This will skip the wasm file fetching.\n        config.wasmBinary = wasmBinaryOverride;\n\n        // Offer an implementation of locateFile() that returns the file name directly. This helps to avoid an error\n        // thrown later from the following code when `import.meta.url` is a blob URL:\n        // ```\n        //   return new URL(\"ort-wasm-simd-threaded.jsep.wasm\", import.meta.url).href;\n        // ```\n        config.locateFile = (fileName) => fileName;\n      } else if (wasmPathOverride || wasmPrefixOverride) {\n        // A callback function to locate the WebAssembly file. The function should return the full path of the file.\n        //\n        // Since Emscripten 3.1.58, this function is only called for the .wasm file.\n        config.locateFile = (fileName) => wasmPathOverride ?? wasmPrefixOverride + fileName;\n      } else if (mjsPathOverride && mjsPathOverride.indexOf('blob:') !== 0) {\n        // if mjs path is specified, use it as the base path for the .wasm file.\n        config.locateFile = (fileName) => new URL(fileName, mjsPathOverride).href;\n      } else if (objectUrl) {\n        const inferredWasmPathPrefix = inferWasmPathPrefixFromScriptSrc();\n        if (inferredWasmPathPrefix) {\n          // if the wasm module is preloaded, use the inferred wasm path as the base path for the .wasm file.\n          config.locateFile = (fileName) => inferredWasmPathPrefix + fileName;\n        }\n      }\n\n      ortWasmFactory(config).then(\n        // wasm module initialized successfully\n        (module) => {\n          initializing = false;\n          initialized = true;\n          wasm = module;\n          resolve();\n          if (objectUrl) {\n            URL.revokeObjectURL(objectUrl);\n          }\n        },\n        // wasm module failed to initialize\n        (what) => {\n          initializing = false;\n          aborted = true;\n          reject(what);\n        },\n      );\n    }),\n  );\n\n  await Promise.race(tasks);\n\n  if (isTimeout) {\n    throw new Error(`WebAssembly backend initializing failed due to timeout: ${timeout}ms`);\n  }\n};\n\nexport const getInstance = (): OrtWasmModule => {\n  if (initialized && wasm) {\n    return wasm;\n  }\n\n  throw new Error('WebAssembly is not initialized yet.');\n};\n\nexport const dispose = (): void => {\n  if (initialized && !initializing && !aborted) {\n    // TODO: currently \"PThread.terminateAllThreads()\" is not exposed in the wasm module.\n    //       And this function is not yet called by any code.\n    //       If it is needed in the future, we should expose it in the wasm module and uncomment the following line.\n\n    // wasm?.PThread?.terminateAllThreads();\n    wasm = undefined;\n\n    initializing = false;\n    initialized = false;\n    aborted = true;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { getInstance } from './wasm-factory';\n\nexport const allocWasmString = (data: string, allocs: number[]): number => {\n  const wasm = getInstance();\n\n  const dataLength = wasm.lengthBytesUTF8(data) + 1;\n  const dataOffset = wasm._malloc(dataLength);\n  wasm.stringToUTF8(data, dataOffset, dataLength);\n  allocs.push(dataOffset);\n\n  return dataOffset;\n};\n\ninterface ExtraOptionsHandler {\n  (name: string, value: string): void;\n}\n\nexport const iterateExtraOptions = (\n  options: Record<string, unknown>,\n  prefix: string,\n  seen: WeakSet<Record<string, unknown>>,\n  handler: ExtraOptionsHandler,\n): void => {\n  if (typeof options == 'object' && options !== null) {\n    if (seen.has(options)) {\n      throw new Error('Circular reference in options');\n    } else {\n      seen.add(options);\n    }\n  }\n\n  Object.entries(options).forEach(([key, value]) => {\n    const name = prefix ? prefix + key : key;\n    if (typeof value === 'object') {\n      iterateExtraOptions(value as Record<string, unknown>, name + '.', seen, handler);\n    } else if (typeof value === 'string' || typeof value === 'number') {\n      handler(name, value.toString());\n    } else if (typeof value === 'boolean') {\n      handler(name, value ? '1' : '0');\n    } else {\n      throw new Error(`Can't handle extra config type: ${typeof value}`);\n    }\n  });\n};\n\n/**\n * check web assembly API's last error and throw error if any error occurred.\n * @param message a message used when an error occurred.\n */\nexport const checkLastError = (message: string): void => {\n  const wasm = getInstance();\n\n  const stack = wasm.stackSave();\n  try {\n    const ptrSize = wasm.PTR_SIZE;\n    const paramsOffset = wasm.stackAlloc(2 * ptrSize);\n    wasm._OrtGetLastError(paramsOffset, paramsOffset + ptrSize);\n    const errorCode = Number(wasm.getValue(paramsOffset, ptrSize === 4 ? 'i32' : 'i64'));\n    const errorMessagePointer = wasm.getValue(paramsOffset + ptrSize, '*');\n    const errorMessage = errorMessagePointer ? wasm.UTF8ToString(errorMessagePointer) : '';\n    throw new Error(`${message} ERROR_CODE: ${errorCode}, ERROR_MESSAGE: ${errorMessage}`);\n  } finally {\n    wasm.stackRestore(stack);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { InferenceSession } from 'onnxruntime-common';\n\nimport { getInstance } from './wasm-factory';\nimport { allocWasmString, checkLastError, iterateExtraOptions } from './wasm-utils';\n\nexport const setRunOptions = (options: InferenceSession.RunOptions): [number, number[]] => {\n  const wasm = getInstance();\n  let runOptionsHandle = 0;\n  const allocs: number[] = [];\n\n  const runOptions: InferenceSession.RunOptions = options || {};\n\n  try {\n    if (options?.logSeverityLevel === undefined) {\n      runOptions.logSeverityLevel = 2; // Default to warning\n    } else if (\n      typeof options.logSeverityLevel !== 'number' ||\n      !Number.isInteger(options.logSeverityLevel) ||\n      options.logSeverityLevel < 0 ||\n      options.logSeverityLevel > 4\n    ) {\n      throw new Error(`log severity level is not valid: ${options.logSeverityLevel}`);\n    }\n\n    if (options?.logVerbosityLevel === undefined) {\n      runOptions.logVerbosityLevel = 0; // Default to 0\n    } else if (typeof options.logVerbosityLevel !== 'number' || !Number.isInteger(options.logVerbosityLevel)) {\n      throw new Error(`log verbosity level is not valid: ${options.logVerbosityLevel}`);\n    }\n\n    if (options?.terminate === undefined) {\n      runOptions.terminate = false;\n    }\n\n    let tagDataOffset = 0;\n    if (options?.tag !== undefined) {\n      tagDataOffset = allocWasmString(options.tag, allocs);\n    }\n\n    runOptionsHandle = wasm._OrtCreateRunOptions(\n      runOptions.logSeverityLevel!,\n      runOptions.logVerbosityLevel!,\n      !!runOptions.terminate!,\n      tagDataOffset,\n    );\n    if (runOptionsHandle === 0) {\n      checkLastError(\"Can't create run options.\");\n    }\n\n    if (options?.extra !== undefined) {\n      iterateExtraOptions(options.extra, '', new WeakSet<Record<string, unknown>>(), (key, value) => {\n        const keyDataOffset = allocWasmString(key, allocs);\n        const valueDataOffset = allocWasmString(value, allocs);\n\n        if (wasm._OrtAddRunConfigEntry(runOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n          checkLastError(`Can't set a run config entry: ${key} - ${value}.`);\n        }\n      });\n    }\n\n    return [runOptionsHandle, allocs];\n  } catch (e) {\n    if (runOptionsHandle !== 0) {\n      wasm._OrtReleaseRunOptions(runOptionsHandle);\n    }\n    allocs.forEach((alloc) => wasm._free(alloc));\n    throw e;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport type { InferenceSession } from 'onnxruntime-common';\n\nimport { getInstance } from './wasm-factory';\nimport { allocWasmString, checkLastError, iterateExtraOptions } from './wasm-utils';\n\nconst getGraphOptimzationLevel = (graphOptimizationLevel: string | unknown): number => {\n  switch (graphOptimizationLevel) {\n    case 'disabled':\n      return 0;\n    case 'basic':\n      return 1;\n    case 'extended':\n      return 2;\n    case 'layout':\n      return 3;\n    case 'all':\n      return 99;\n    default:\n      throw new Error(`unsupported graph optimization level: ${graphOptimizationLevel}`);\n  }\n};\n\nconst getExecutionMode = (executionMode: 'sequential' | 'parallel'): number => {\n  switch (executionMode) {\n    case 'sequential':\n      return 0;\n    case 'parallel':\n      return 1;\n    default:\n      throw new Error(`unsupported execution mode: ${executionMode}`);\n  }\n};\n\nconst appendDefaultOptions = (options: InferenceSession.SessionOptions): void => {\n  if (!options.extra) {\n    options.extra = {};\n  }\n  if (!options.extra.session) {\n    options.extra.session = {};\n  }\n  const session = options.extra.session as Record<string, string>;\n  if (!session.use_ort_model_bytes_directly) {\n    // eslint-disable-next-line camelcase\n    session.use_ort_model_bytes_directly = '1';\n  }\n\n  // if using JSEP with WebGPU, always disable memory pattern\n  if (\n    options.executionProviders &&\n    options.executionProviders.some((ep) => (typeof ep === 'string' ? ep : ep.name) === 'webgpu')\n  ) {\n    options.enableMemPattern = false;\n  }\n};\n\nconst appendSessionConfig = (sessionOptionsHandle: number, key: string, value: string, allocs: number[]): void => {\n  const keyDataOffset = allocWasmString(key, allocs);\n  const valueDataOffset = allocWasmString(value, allocs);\n  if (getInstance()._OrtAddSessionConfigEntry(sessionOptionsHandle, keyDataOffset, valueDataOffset) !== 0) {\n    checkLastError(`Can't set a session config entry: ${key} - ${value}.`);\n  }\n};\n\nconst appendEpOption = (epOptions: Array<[number, number]>, key: string, value: string, allocs: number[]): void => {\n  const keyDataOffset = allocWasmString(key, allocs);\n  const valueDataOffset = allocWasmString(value, allocs);\n  epOptions.push([keyDataOffset, valueDataOffset]);\n};\n\nconst setExecutionProviders = async (\n  sessionOptionsHandle: number,\n  sessionOptions: InferenceSession.SessionOptions,\n  allocs: number[],\n): Promise<void> => {\n  const executionProviders = sessionOptions.executionProviders!;\n  for (const ep of executionProviders) {\n    let epName = typeof ep === 'string' ? ep : ep.name;\n    const epOptions: Array<[number, number]> = [];\n\n    // check EP name\n    switch (epName) {\n      case 'webnn':\n        epName = 'WEBNN';\n        // Disable QDQ fusion so DQ/Q nodes are preserved as individual ops for WebNN EP.\n        appendSessionConfig(sessionOptionsHandle, 'session.disable_quant_qdq', '1', allocs);\n        // Forcibly prevent constant folding from replacing DQ nodes with constants.\n        appendSessionConfig(sessionOptionsHandle, 'session.disable_qdq_constant_folding', '1', allocs);\n        if (typeof ep !== 'string') {\n          const webnnOptions = ep as InferenceSession.WebNNExecutionProviderOption;\n          // const context = (webnnOptions as InferenceSession.WebNNOptionsWithMLContext)?.context;\n          const deviceType = (webnnOptions as InferenceSession.WebNNContextOptions)?.deviceType;\n          if (deviceType) {\n            appendSessionConfig(sessionOptionsHandle, 'deviceType', deviceType, allocs);\n          }\n        }\n        break;\n      case 'webgpu':\n        if (!BUILD_DEFS.DISABLE_WEBGPU) {\n          epName = 'WebGPU';\n          let customDevice: GPUDevice | undefined;\n\n          if (typeof ep !== 'string') {\n            const webgpuOptions = ep as InferenceSession.WebGpuExecutionProviderOption;\n\n            // set custom GPU device\n            if (webgpuOptions.device) {\n              if (typeof GPUDevice !== 'undefined' && webgpuOptions.device instanceof GPUDevice) {\n                customDevice = webgpuOptions.device;\n              } else {\n                throw new Error('Invalid GPU device set in WebGPU EP options.');\n              }\n            }\n\n            // set graph capture option from session options\n            const { enableGraphCapture } = sessionOptions;\n            if (typeof enableGraphCapture === 'boolean' && enableGraphCapture) {\n              appendEpOption(epOptions, 'enableGraphCapture', '1', allocs);\n            }\n\n            // set layout option\n            if (typeof webgpuOptions.preferredLayout === 'string') {\n              appendEpOption(epOptions, 'preferredLayout', webgpuOptions.preferredLayout, allocs);\n            }\n\n            // set force CPU fallback nodes\n            if (webgpuOptions.forceCpuNodeNames) {\n              const names = Array.isArray(webgpuOptions.forceCpuNodeNames)\n                ? webgpuOptions.forceCpuNodeNames\n                : [webgpuOptions.forceCpuNodeNames];\n\n              appendEpOption(epOptions, 'forceCpuNodeNames', names.join('\\n'), allocs);\n            }\n\n            // set validation mode\n            if (webgpuOptions.validationMode) {\n              appendEpOption(epOptions, 'validationMode', webgpuOptions.validationMode, allocs);\n            }\n          }\n\n          const info = getInstance().webgpuRegisterDevice!(customDevice);\n          if (info) {\n            const [deviceId, instanceHandle, deviceHandle] = info;\n            appendEpOption(epOptions, 'deviceId', deviceId.toString(), allocs);\n            appendEpOption(epOptions, 'webgpuInstance', instanceHandle.toString(), allocs);\n            appendEpOption(epOptions, 'webgpuDevice', deviceHandle.toString(), allocs);\n          }\n        } else {\n          epName = 'JS';\n          if (typeof ep !== 'string') {\n            const webgpuOptions = ep as InferenceSession.WebGpuExecutionProviderOption;\n            if (webgpuOptions?.preferredLayout) {\n              if (webgpuOptions.preferredLayout !== 'NCHW' && webgpuOptions.preferredLayout !== 'NHWC') {\n                throw new Error(`preferredLayout must be either 'NCHW' or 'NHWC': ${webgpuOptions.preferredLayout}`);\n              }\n              appendSessionConfig(sessionOptionsHandle, 'preferredLayout', webgpuOptions.preferredLayout, allocs);\n            }\n          }\n        }\n        break;\n      case 'wasm':\n      case 'cpu':\n        continue;\n      default:\n        throw new Error(`not supported execution provider: ${epName}`);\n    }\n\n    const epNameDataOffset = allocWasmString(epName, allocs);\n    const epOptionsCount = epOptions.length;\n    let keysOffset = 0;\n    let valuesOffset = 0;\n    if (epOptionsCount > 0) {\n      keysOffset = getInstance()._malloc(epOptionsCount * getInstance().PTR_SIZE);\n      allocs.push(keysOffset);\n      valuesOffset = getInstance()._malloc(epOptionsCount * getInstance().PTR_SIZE);\n      allocs.push(valuesOffset);\n      for (let i = 0; i < epOptionsCount; i++) {\n        getInstance().setValue(keysOffset + i * getInstance().PTR_SIZE, epOptions[i][0], '*');\n        getInstance().setValue(valuesOffset + i * getInstance().PTR_SIZE, epOptions[i][1], '*');\n      }\n    }\n    if (\n      (await getInstance()._OrtAppendExecutionProvider(\n        sessionOptionsHandle,\n        epNameDataOffset,\n        keysOffset,\n        valuesOffset,\n        epOptionsCount,\n      )) !== 0\n    ) {\n      checkLastError(`Can't append execution provider: ${epName}.`);\n    }\n  }\n};\n\nexport const setSessionOptions = async (options?: InferenceSession.SessionOptions): Promise<[number, number[]]> => {\n  const wasm = getInstance();\n  let sessionOptionsHandle = 0;\n  const allocs: number[] = [];\n\n  const sessionOptions: InferenceSession.SessionOptions = options || {};\n  appendDefaultOptions(sessionOptions);\n\n  try {\n    const graphOptimizationLevel = getGraphOptimzationLevel(sessionOptions.graphOptimizationLevel ?? 'all');\n    const executionMode = getExecutionMode(sessionOptions.executionMode ?? 'sequential');\n    const logIdDataOffset =\n      typeof sessionOptions.logId === 'string' ? allocWasmString(sessionOptions.logId, allocs) : 0;\n\n    const logSeverityLevel = sessionOptions.logSeverityLevel ?? 2; // Default to 2 - warning\n    if (!Number.isInteger(logSeverityLevel) || logSeverityLevel < 0 || logSeverityLevel > 4) {\n      throw new Error(`log severity level is not valid: ${logSeverityLevel}`);\n    }\n\n    const logVerbosityLevel = sessionOptions.logVerbosityLevel ?? 0; // Default to 0 - verbose\n    if (!Number.isInteger(logVerbosityLevel) || logVerbosityLevel < 0 || logVerbosityLevel > 4) {\n      throw new Error(`log verbosity level is not valid: ${logVerbosityLevel}`);\n    }\n\n    const optimizedModelFilePathOffset =\n      typeof sessionOptions.optimizedModelFilePath === 'string'\n        ? allocWasmString(sessionOptions.optimizedModelFilePath, allocs)\n        : 0;\n\n    sessionOptionsHandle = wasm._OrtCreateSessionOptions(\n      graphOptimizationLevel,\n      !!sessionOptions.enableCpuMemArena,\n      !!sessionOptions.enableMemPattern,\n      executionMode,\n      !!sessionOptions.enableProfiling,\n      0,\n      logIdDataOffset,\n      logSeverityLevel,\n      logVerbosityLevel,\n      optimizedModelFilePathOffset,\n    );\n    if (sessionOptionsHandle === 0) {\n      checkLastError(\"Can't create session options.\");\n    }\n\n    if (sessionOptions.executionProviders) {\n      await setExecutionProviders(sessionOptionsHandle, sessionOptions, allocs);\n    }\n\n    if (sessionOptions.enableGraphCapture !== undefined) {\n      if (typeof sessionOptions.enableGraphCapture !== 'boolean') {\n        throw new Error(`enableGraphCapture must be a boolean value: ${sessionOptions.enableGraphCapture}`);\n      }\n      appendSessionConfig(\n        sessionOptionsHandle,\n        'enableGraphCapture',\n        sessionOptions.enableGraphCapture.toString(),\n        allocs,\n      );\n    }\n\n    if (sessionOptions.freeDimensionOverrides) {\n      for (const [name, value] of Object.entries(sessionOptions.freeDimensionOverrides)) {\n        if (typeof name !== 'string') {\n          throw new Error(`free dimension override name must be a string: ${name}`);\n        }\n        if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {\n          throw new Error(`free dimension override value must be a non-negative integer: ${value}`);\n        }\n        const nameOffset = allocWasmString(name, allocs);\n        if (wasm._OrtAddFreeDimensionOverride(sessionOptionsHandle, nameOffset, value) !== 0) {\n          checkLastError(`Can't set a free dimension override: ${name} - ${value}.`);\n        }\n      }\n    }\n\n    if (sessionOptions.extra !== undefined) {\n      iterateExtraOptions(sessionOptions.extra, '', new WeakSet<Record<string, unknown>>(), (key, value) => {\n        appendSessionConfig(sessionOptionsHandle, key, value, allocs);\n      });\n    }\n\n    return [sessionOptionsHandle, allocs];\n  } catch (e) {\n    if (sessionOptionsHandle !== 0) {\n      if (wasm._OrtReleaseSessionOptions(sessionOptionsHandle) !== 0) {\n        checkLastError(\"Can't release session options.\");\n      }\n    }\n    allocs.forEach((alloc) => wasm._free(alloc));\n    throw e;\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from 'onnxruntime-common';\n\n// a dummy type declaration for Float16Array in case any polyfill is available.\ndeclare global {\n  // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-explicit-any\n  const Float16Array: any;\n}\n\n// This file includes common definitions. They do NOT have dependency on the WebAssembly instance.\n\n/**\n * Copied from ONNX definition. Use this to drop dependency 'onnx_proto' to decrease compiled .js file size.\n */\nexport const enum DataType {\n  undefined = 0,\n  float = 1,\n  uint8 = 2,\n  int8 = 3,\n  uint16 = 4,\n  int16 = 5,\n  int32 = 6,\n  int64 = 7,\n  string = 8,\n  bool = 9,\n  float16 = 10,\n  double = 11,\n  uint32 = 12,\n  uint64 = 13,\n  complex64 = 14,\n  complex128 = 15,\n  bfloat16 = 16,\n\n  // 4-bit data-types\n  uint4 = 21,\n  int4 = 22,\n}\n\n/**\n * Map string tensor data to enum value\n */\nexport const tensorDataTypeStringToEnum = (type: string): DataType => {\n  switch (type) {\n    case 'int8':\n      return DataType.int8;\n    case 'uint8':\n      return DataType.uint8;\n    case 'bool':\n      return DataType.bool;\n    case 'int16':\n      return DataType.int16;\n    case 'uint16':\n      return DataType.uint16;\n    case 'int32':\n      return DataType.int32;\n    case 'uint32':\n      return DataType.uint32;\n    case 'float16':\n      return DataType.float16;\n    case 'float32':\n      return DataType.float;\n    case 'float64':\n      return DataType.double;\n    case 'string':\n      return DataType.string;\n    case 'int64':\n      return DataType.int64;\n    case 'uint64':\n      return DataType.uint64;\n    case 'int4':\n      return DataType.int4;\n    case 'uint4':\n      return DataType.uint4;\n\n    default:\n      throw new Error(`unsupported data type: ${type}`);\n  }\n};\n\n/**\n * Map enum value to string tensor data\n */\nexport const tensorDataTypeEnumToString = (typeProto: DataType): Tensor.Type => {\n  switch (typeProto) {\n    case DataType.int8:\n      return 'int8';\n    case DataType.uint8:\n      return 'uint8';\n    case DataType.bool:\n      return 'bool';\n    case DataType.int16:\n      return 'int16';\n    case DataType.uint16:\n      return 'uint16';\n    case DataType.int32:\n      return 'int32';\n    case DataType.uint32:\n      return 'uint32';\n    case DataType.float16:\n      return 'float16';\n    case DataType.float:\n      return 'float32';\n    case DataType.double:\n      return 'float64';\n    case DataType.string:\n      return 'string';\n    case DataType.int64:\n      return 'int64';\n    case DataType.uint64:\n      return 'uint64';\n    case DataType.int4:\n      return 'int4';\n    case DataType.uint4:\n      return 'uint4';\n\n    default:\n      throw new Error(`unsupported data type: ${typeProto}`);\n  }\n};\n\n/**\n * get tensor size in bytes by the given data type and dimensions\n * @returns size in integer or undefined if the data type is not supported\n */\nexport const calculateTensorSizeInBytes = (\n  dateType: number,\n  dimsOrSize: readonly number[] | number,\n): number | undefined => {\n  const elementSize = [\n    -1, // undefined = 0\n    4, // float = 1\n    1, // uint8 = 2\n    1, // int8 = 3\n    2, // uint16 = 4\n    2, // int16 = 5\n    4, // int32 = 6\n    8, // int64 = 7\n    -1, // string = 8\n    1, // bool = 9\n    2, // float16 = 10\n    8, // double = 11\n    4, // uint32 = 12\n    8, // uint64 = 13\n    -1, // complex64 = 14\n    -1, // complex128 = 15\n    -1, // bfloat16 = 16\n    -1, // FLOAT8E4M3FN = 17\n    -1, // FLOAT8E4M3FNUZ = 18\n    -1, // FLOAT8E5M2 = 19\n    -1, // FLOAT8E5M2FNUZ = 20\n    0.5, // uint4 = 21\n    0.5, // int4 = 22\n  ][dateType];\n\n  const size = typeof dimsOrSize === 'number' ? dimsOrSize : dimsOrSize.reduce((a, b) => a * b, 1);\n  return elementSize > 0 ? Math.ceil(size * elementSize) : undefined;\n};\n\n/**\n * get typed array constructor by the given tensor type\n */\nexport const tensorTypeToTypedArrayConstructor = (\n  type: Tensor.Type,\n):\n  | Float32ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int8ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int16ArrayConstructor\n  | Int32ArrayConstructor\n  | BigInt64ArrayConstructor\n  | Uint8ArrayConstructor\n  | Float64ArrayConstructor\n  | Uint32ArrayConstructor\n  | BigUint64ArrayConstructor => {\n  switch (type) {\n    case 'float16':\n      // allow Float16Array polyfill.\n      return typeof Float16Array !== 'undefined' && Float16Array.from ? Float16Array : Uint16Array;\n    case 'float32':\n      return Float32Array;\n    case 'uint8':\n      return Uint8Array;\n    case 'int8':\n      return Int8Array;\n    case 'uint16':\n      return Uint16Array;\n    case 'int16':\n      return Int16Array;\n    case 'int32':\n      return Int32Array;\n    case 'bool':\n      return Uint8Array;\n    case 'float64':\n      return Float64Array;\n    case 'uint32':\n      return Uint32Array;\n    case 'int64':\n      return BigInt64Array;\n    case 'uint64':\n      return BigUint64Array;\n    default:\n      throw new Error(`unsupported type: ${type}`);\n  }\n};\n\n/**\n * Map string log level to integer value\n */\nexport const logLevelStringToEnum = (logLevel?: 'verbose' | 'info' | 'warning' | 'error' | 'fatal'): number => {\n  switch (logLevel) {\n    case 'verbose':\n      return 0;\n    case 'info':\n      return 1;\n    case 'warning':\n      return 2;\n    case 'error':\n      return 3;\n    case 'fatal':\n      return 4;\n    default:\n      throw new Error(`unsupported logging level: ${logLevel}`);\n  }\n};\n\n/**\n * Check whether the given tensor type is supported by GPU buffer\n */\nexport const isGpuBufferSupportedType = (type: Tensor.Type): type is Tensor.GpuBufferDataTypes =>\n  type === 'float32' ||\n  type === 'float16' ||\n  type === 'int32' ||\n  type === 'int64' ||\n  type === 'uint32' ||\n  type === 'uint8' ||\n  type === 'bool' ||\n  type === 'uint4' ||\n  type === 'int4';\n\n/**\n * Check whether the given tensor type is supported by WebNN MLTensor\n */\nexport const isMLTensorSupportedType = (type: Tensor.Type): type is Tensor.MLTensorDataTypes =>\n  type === 'float32' ||\n  type === 'float16' ||\n  type === 'int32' ||\n  type === 'int64' ||\n  type === 'uint32' ||\n  type === 'uint64' ||\n  type === 'int8' ||\n  type === 'uint8' ||\n  type === 'bool' ||\n  type === 'uint4' ||\n  type === 'int4';\n\n/**\n * Map string data location to integer value\n */\nexport const dataLocationStringToEnum = (location: Tensor.DataLocation): number => {\n  switch (location) {\n    case 'none':\n      return 0;\n    case 'cpu':\n      return 1;\n    case 'cpu-pinned':\n      return 2;\n    case 'texture':\n      return 3;\n    case 'gpu-buffer':\n      return 4;\n    case 'ml-tensor':\n      return 5;\n    default:\n      throw new Error(`unsupported data location: ${location}`);\n  }\n};\n\n/**\n * Map integer data location to string value\n */\nexport const dataLocationEnumToString = (location: number): Tensor.DataLocation | undefined =>\n  (['none', 'cpu', 'cpu-pinned', 'texture', 'gpu-buffer', 'ml-tensor'] as const)[location];\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { isNode } from './wasm-utils-env';\n\n/**\n * Load a file into a Uint8Array.\n *\n * @param file - the file to load. Can be a URL/path, a Blob, an ArrayBuffer, or a Uint8Array.\n * @returns a Uint8Array containing the file data.\n */\nexport const loadFile = async (file: string | Blob | ArrayBufferLike | Uint8Array): Promise<Uint8Array> => {\n  if (typeof file === 'string') {\n    if (isNode) {\n      // load file into ArrayBuffer in Node.js\n      try {\n        const { readFile } = require('node:fs/promises');\n        return new Uint8Array(await readFile(file));\n      } catch (e) {\n        if (e.code === 'ERR_FS_FILE_TOO_LARGE') {\n          // file is too large, use fs.createReadStream instead\n          const { createReadStream } = require('node:fs');\n          const stream = createReadStream(file);\n          const chunks: Uint8Array[] = [];\n          for await (const chunk of stream) {\n            chunks.push(chunk);\n          }\n          return new Uint8Array(Buffer.concat(chunks));\n        }\n        throw e;\n      }\n    } else {\n      // load file into ArrayBuffer in browsers\n      const response = await fetch(file);\n      if (!response.ok) {\n        throw new Error(`failed to load external data file: ${file}`);\n      }\n      const contentLengthHeader = response.headers.get('Content-Length');\n      const fileSize = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;\n      if (fileSize < 1073741824 /* 1GB */) {\n        // when Content-Length header is not set, we cannot determine the file size. We assume it is small enough to\n        // load into memory.\n        return new Uint8Array(await response.arrayBuffer());\n      } else {\n        // file is too large, use stream instead\n        if (!response.body) {\n          throw new Error(`failed to load external data file: ${file}, no response body.`);\n        }\n        const reader = response.body.getReader();\n\n        let buffer;\n        try {\n          // try to create ArrayBuffer directly\n          buffer = new ArrayBuffer(fileSize);\n        } catch (e) {\n          if (e instanceof RangeError) {\n            // use WebAssembly Memory to allocate larger ArrayBuffer\n            const pages = Math.ceil(fileSize / 65536);\n            buffer = new WebAssembly.Memory({ initial: pages, maximum: pages }).buffer;\n          } else {\n            throw e;\n          }\n        }\n\n        let offset = 0;\n        while (true) {\n          const { done, value } = await reader.read();\n          if (done) {\n            break;\n          }\n          const chunkSize = value.byteLength;\n          const chunk = new Uint8Array(buffer, offset, chunkSize);\n          chunk.set(value);\n          offset += chunkSize;\n        }\n        return new Uint8Array(buffer, 0, fileSize);\n      }\n    }\n  } else if (file instanceof Blob) {\n    return new Uint8Array(await file.arrayBuffer());\n  } else if (file instanceof Uint8Array) {\n    return file;\n  } else {\n    return new Uint8Array(file);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Env } from 'onnxruntime-common';\n\nimport { logLevelStringToEnum } from '../wasm-common';\n\ntype LogLevel = NonNullable<Env['logLevel']>;\ntype MessageString = string;\ntype MessageFunction = () => string;\ntype Message = MessageString | MessageFunction;\n\nconst logLevelPrefix = ['V', 'I', 'W', 'E', 'F'];\n\nconst doLog = (level: number, message: string): void => {\n  // eslint-disable-next-line no-console\n  console.log(`[${logLevelPrefix[level]},${new Date().toISOString()}]${message}`);\n};\n\nlet configLogLevel: LogLevel | undefined;\nlet debug: boolean | undefined;\n\nexport const configureLogger = ($configLogLevel: LogLevel, $debug: boolean): void => {\n  configLogLevel = $configLogLevel;\n  debug = $debug;\n};\n\n/**\n * A simple logging utility to log messages to the console.\n */\nexport const LOG = (logLevel: LogLevel, msg: Message): void => {\n  const messageLevel = logLevelStringToEnum(logLevel);\n  const configLevel = logLevelStringToEnum(configLogLevel);\n  if (messageLevel >= configLevel) {\n    doLog(messageLevel, typeof msg === 'function' ? msg() : msg);\n  }\n};\n\n/**\n * A simple logging utility to log messages to the console. Only logs when debug is enabled.\n */\nexport const LOG_DEBUG: typeof LOG = (...args: Parameters<typeof LOG>) => {\n  if (debug) {\n    LOG(...args);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/* eslint-disable no-param-reassign */\n\nexport class MatMulUtil {\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      const max = Math.max(aLen, bLen);\n      if (aLen && bLen) {\n        cdims[crank - i] = Math.max(aLen, bLen);\n      } else {\n        // when either aLen or bLen is 0, the other should be either 0 or 1, otherwise it is not broadcastable.\n        if (max > 1) {\n          return undefined;\n        }\n        cdims[crank - i] = 0;\n      }\n    }\n\n    return cdims;\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\nexport class ShapeUtil {\n  /**\n   * calculate the size (number of elements)\n   */\n  static size(dims: readonly number[]): number {\n    return ShapeUtil.getSizeFromDimensionRange(dims, 0, dims.length);\n  }\n\n  /**\n   * convert dims corresponding to type change to pack. ex. uint8 data to uint32\n   */\n  static convertShape(dims: readonly number[], size = 4): readonly number[] {\n    const rank = dims.length;\n    if (rank === 0) {\n      return [];\n    }\n    const newDims = new Array(rank);\n    let i = rank - 1;\n    while (i >= 0) {\n      if (dims[i] % size === 0) {\n        newDims[i] = dims[i] / size;\n        break;\n      }\n      if (size % dims[i] !== 0) {\n        throw new Error('cannot convert shape');\n      }\n      newDims[i] = 1;\n      size /= dims[i];\n      i--;\n    }\n    for (i--; i >= 0; i--) {\n      newDims[i] = dims[i];\n    }\n    return newDims;\n  }\n\n  /**\n   * calculate the size (number of elements) from the given axis (inclusive)\n   */\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  /**\n   * calculate the size (number of elements) to the given axis (exclusive)\n   */\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  /**\n   * calculate the size (number of elements) from and to the given axis [start, end)\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 negative.\n      if (dims[i] < 0) {\n        throw new Error(\n          'cannot get valid size from specified dimension range. Most likely the range contains negative values in them.',\n        );\n      }\n      size *= Number(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  /**\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 ?? axes.length));\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\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  ): void {\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    isChannelLast: boolean,\n    autoPad?: string,\n  ): void {\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 + (isChannelLast ? 1 : 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   */\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  ): 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    );\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  ) {\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          ),\n        );\n      }\n    }\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  ): 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 Math.floor((inSize - dkernel) / stride + 1);\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            const legacyTargetSize = (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 Math.floor((inSize + padNeeded - kernel) / stride + 1);\n          }\n        default:\n          throw new Error('Unsupported AutoPad type');\n      }\n    } else {\n      return Math.floor((inSize + pads[padHeadIndex] + pads[padTailIndex] - dkernel) / stride + 1);\n    }\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 const MIN_CLIP = -3.4028234663852886e38;\nexport const MAX_CLIP = 3.4028234663852886e38;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Tensor } from 'onnxruntime-common';\n\nimport { tensorTypeToTypedArrayConstructor } from '../wasm-common';\n\nexport const createView = (\n  dataBuffer: ArrayBuffer,\n  type: Tensor.Type,\n):\n  | Int32Array\n  | Uint32Array\n  | BigInt64Array\n  | BigUint64Array\n  | Uint8Array\n  | Float32Array\n  | Float64Array\n  | Int8Array\n  | Int16Array\n  | Uint16Array => new (tensorTypeToTypedArrayConstructor(type))(dataBuffer);\n\n/**\n * a TensorView does not own the data.\n */\nexport interface TensorView {\n  readonly data: number;\n  readonly dataType: number;\n  readonly dims: readonly number[];\n\n  /**\n   * get a Float16Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getUint16Array(): Uint16Array;\n\n  /**\n   * get a Float32Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getFloat32Array(): Float32Array;\n\n  /**\n   * get a BigInt64Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getBigInt64Array(): BigInt64Array;\n\n  /**\n   * get a Int32Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getInt32Array(): Int32Array;\n\n  /**\n   * get a Uint16Array data view of the tensor data. tensor data must be on CPU.\n   */\n  getUint16Array(): Uint16Array;\n\n  /**\n   * create a new tensor view with the same data but different dimensions.\n   */\n  reshape(newDims: readonly number[]): TensorView;\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { WebNNBackend } from '../backend-webnn';\nimport { tensorTypeToTypedArrayConstructor } from '../../wasm-common';\nimport { LOG_DEBUG } from '../log';\n\n// WebNN API currently does not have a TypeScript definition file. This file is a workaround with types generated from\n// WebNN API specification.\n// https://github.com/webmachinelearning/webnn/issues/677\n/// <reference path=\"webnn.d.ts\" />\n\n/**\n * Map from MLOperandDataType to size in bits. Using bits instead of bytes to avoid possible precision loss on int4 and uint4.\n */\nconst webnnDataTypeToSize = new Map<MLOperandDataType, number>([\n  ['float32', 32],\n  ['float16', 16],\n  ['int32', 32],\n  ['uint32', 32],\n  ['int64', 64],\n  ['uint64', 64],\n  ['int8', 8],\n  ['uint8', 8],\n  ['int4', 4],\n  ['uint4', 4],\n]);\n\n// Convert integer data to an Int32Array buffer.\n// Supports conversion from int64, uint64, uint32, int8 and uint8 to int32.\nexport const convertDataToInt32 = (data: Uint8Array, dataType: MLOperandDataType): Uint8Array => {\n  if (dataType === 'int32') {\n    return data;\n  }\n\n  const dataTypeSize = webnnDataTypeToSize.get(dataType);\n  if (!dataTypeSize) {\n    throw new Error(`WebNN backend does not support data type: ${dataType}`);\n  }\n  const bytesPerElement = dataTypeSize / 8;\n  // Make sure the data length is a multiple of the data type size.\n  if (data.byteLength % bytesPerElement !== 0) {\n    throw new Error(`Invalid Uint8Array length - must be a multiple of ${bytesPerElement}.`);\n  }\n\n  // Convert Uint8Array to original typed array.\n  const numElements = data.byteLength / bytesPerElement;\n  const originalArray = new (tensorTypeToTypedArrayConstructor(dataType))(data.buffer, data.byteOffset, numElements);\n\n  switch (dataType) {\n    case 'int64':\n    case 'uint64': {\n      // Convert original typed array to Int32Array.\n      const int32Array = new Int32Array(numElements);\n      for (let i = 0; i < numElements; i++) {\n        const value = originalArray[i];\n\n        // Check for overflow.\n        if (value > 2147483647n || value < -2147483648n) {\n          throw new Error(`Can not convert int64 data to int32 - value out of range.`);\n        }\n\n        int32Array[i] = Number(value);\n      }\n\n      return new Uint8Array(int32Array.buffer);\n    }\n    case 'int8':\n    case 'uint8':\n    case 'uint32': {\n      // Check for overflow.\n      if (dataType === 'uint32') {\n        if (originalArray.some((value) => value > 2147483647)) {\n          throw new Error(`Can not convert uint32 data to int32 - value out of range.`);\n        }\n      }\n      // Convert original typed array to Int32Array.\n      const int32Array = Int32Array.from(originalArray, Number);\n      return new Uint8Array(int32Array.buffer);\n    }\n    default:\n      throw new Error(`Unsupported data conversion from ${dataType} to 'int32'`);\n  }\n};\n\n// Convert Int32Array data to original integer data buffer.\n// Supports conversion from int32 to int64, uint64, uint32, int8 and uint8.\nexport const convertInt32ToData = (data: Uint8Array, dataType: MLOperandDataType): Uint8Array => {\n  if (dataType === 'int32') {\n    return data;\n  }\n\n  // Make sure the data length is a multiple of 4 bytes (Int32Array).\n  if (data.byteLength % 4 !== 0) {\n    throw new Error('Invalid Uint8Array length - must be a multiple of 4 (int32).');\n  }\n\n  // Convert Uint8Array to Int32Array.\n  const numElements = data.byteLength / 4;\n  const int32Array = new Int32Array(data.buffer, data.byteOffset, numElements);\n\n  switch (dataType) {\n    case 'int64': {\n      const bigInt64Array = BigInt64Array.from(int32Array, BigInt);\n      return new Uint8Array(bigInt64Array.buffer);\n    }\n    case 'uint64': {\n      if (int32Array.some((value) => value < 0)) {\n        throw new Error('Can not convert int32 data to uin64 - negative value found.');\n      }\n      const bigUint64Array = BigUint64Array.from(int32Array, BigInt);\n      return new Uint8Array(bigUint64Array.buffer);\n    }\n    case 'int8': {\n      if (int32Array.some((value) => value < -128 || value > 127)) {\n        throw new Error('Can not convert int32 data to int8 - value out of range.');\n      }\n      const int8Array = Int8Array.from(int32Array, Number);\n      return new Uint8Array(int8Array.buffer);\n    }\n    case 'uint8': {\n      if (int32Array.some((value) => value < 0 || value > 255)) {\n        throw new Error('Can not convert int32 data to uint8 - value out of range.');\n      }\n      return Uint8Array.from(int32Array, Number);\n    }\n    case 'uint32': {\n      if (int32Array.some((value) => value < 0)) {\n        throw new Error('Can not convert int32 data to uint32 - negative value found.');\n      }\n      const uint32Array = Uint32Array.from(int32Array, Number);\n      return new Uint8Array(uint32Array.buffer);\n    }\n    default:\n      throw new Error(`Unsupported data conversion from 'int32' to ${dataType}`);\n  }\n};\n\nexport type TensorId = number;\n\n/**\n * Manages TensorId to MLTensor mapping.\n */\nexport interface TensorManager {\n  /**\n   * Reserve a new TensorId.\n   */\n  reserveTensorId(): TensorId;\n  /**\n   * Release a TensorId.\n   */\n  releaseTensorId(tensorId: TensorId): void;\n  /**\n   * Ensure a MLTensor is created for the TensorId.\n   */\n  ensureTensor(\n    sessionId: number,\n    tensorId: TensorId,\n    dataType: MLOperandDataType,\n    shape: readonly number[],\n    copyOld: boolean,\n  ): Promise<MLTensor>;\n  /**\n   * Upload data to a MLTensor.\n   */\n  upload(tensorId: TensorId, data: Uint8Array): void;\n  /**\n   * Download data from a MLTensor.\n   */\n  download(tensorId: TensorId): Promise<ArrayBuffer>;\n  download(tensorId: TensorId, dstTensor: ArrayBufferView | ArrayBuffer): Promise<undefined>;\n  /**\n   * Release all tensors for a given session.\n   */\n  releaseTensorsForSession(session: number): void;\n  /**\n   * Register an externally created MLTensor with a given session id and return a TensorId.\n   */\n  registerTensor(sessionId: number, mlTensor: MLTensor, dataType: MLOperandDataType, shape: number[]): TensorId;\n}\n\nlet tensorGuid = 1;\nconst createNewTensorId = (): TensorId => tensorGuid++;\n\n/**\n * Map from data type to fallback data type.\n * When the context does not support the original data type, use fallback data type as workaround.\n * Note: Currently, we only support fallback to int32 for certain integer data types.\n */\nconst webnnDataTypeToFallback = new Map<MLOperandDataType, MLOperandDataType>([\n  ['int8', 'int32'],\n  ['uint8', 'int32'],\n  ['uint32', 'int32'],\n  ['int64', 'int32'],\n]);\n\n/**\n * Calculate the byte length of a tensor with the given data type and shape.\n */\nconst calculateByteLength = (dataType: MLOperandDataType, shape: readonly number[]): number => {\n  const dataTypeSize = webnnDataTypeToSize.get(dataType);\n  if (!dataTypeSize) {\n    throw new Error(`WebNN backend does not support data type: ${dataType}`);\n  }\n  return shape.length > 0 ? Math.ceil((shape.reduce((a, b) => a * b) * dataTypeSize) / 8) : 0;\n};\n\n/**\n * TensorWrapper wraps an MLTensor and provides a way to track the last session that used it.\n */\nclass TensorWrapper {\n  // The id of the last session that used this tensor.\n  public sessionId: number;\n  // This flag is used to indicate whether the data has been converted to fallback data type.\n  public isDataConverted = false;\n\n  private mlContext: MLContext;\n  private mlTensor: MLTensor;\n  private dataType: MLOperandDataType;\n  // Fallback data type to use when the context does not support the original data type.\n  private fallbackDataType: MLOperandDataType | undefined;\n  private tensorShape: readonly number[];\n\n  constructor(descriptor: {\n    sessionId: number;\n    context: MLContext;\n    tensor: MLTensor;\n    dataType: MLOperandDataType;\n    shape: readonly number[];\n    fallbackDataType?: MLOperandDataType;\n  }) {\n    const { sessionId, context, tensor, dataType, shape, fallbackDataType } = descriptor;\n    this.sessionId = sessionId;\n    this.mlContext = context;\n    this.mlTensor = tensor;\n    this.dataType = dataType;\n    this.tensorShape = shape;\n    this.fallbackDataType = fallbackDataType;\n  }\n\n  public get tensor(): MLTensor {\n    return this.mlTensor;\n  }\n\n  public get type(): MLOperandDataType {\n    return this.dataType;\n  }\n\n  public get fallbackType(): MLOperandDataType | undefined {\n    return this.fallbackDataType;\n  }\n\n  public get shape(): readonly number[] {\n    return this.tensorShape;\n  }\n\n  public get byteLength(): number {\n    return calculateByteLength(this.dataType, this.tensorShape);\n  }\n\n  public destroy(): void {\n    LOG_DEBUG('verbose', () => '[WebNN] TensorWrapper.destroy');\n    this.mlTensor.destroy();\n  }\n\n  public write(data: Uint8Array): void {\n    this.mlContext.writeTensor(this.mlTensor, data);\n  }\n\n  public async read(): Promise<ArrayBuffer>;\n  public async read(dstBuffer?: ArrayBufferView | ArrayBuffer): Promise<ArrayBuffer | undefined>;\n  public async read(dstBuffer?: ArrayBufferView | ArrayBuffer): Promise<ArrayBuffer | undefined> {\n    if (this.fallbackDataType) {\n      // This tensor has been fallback to int32 as workaround, we need to read it as its original integer data type.\n      const data = await this.mlContext.readTensor(this.mlTensor);\n      const originalData = convertInt32ToData(new Uint8Array(data), this.dataType);\n\n      if (dstBuffer) {\n        const targetBuffer =\n          dstBuffer instanceof ArrayBuffer\n            ? new Uint8Array(dstBuffer)\n            : new Uint8Array(dstBuffer.buffer, dstBuffer.byteOffset, dstBuffer.byteLength);\n        targetBuffer.set(originalData);\n        return undefined;\n      } else {\n        return originalData.buffer;\n      }\n    } else {\n      return dstBuffer ? this.mlContext.readTensor(this.mlTensor, dstBuffer) : this.mlContext.readTensor(this.mlTensor);\n    }\n  }\n\n  public canReuseTensor(context: MLContext, dataType: MLOperandDataType, shape: readonly number[]): boolean {\n    return (\n      this.mlContext === context &&\n      this.dataType === dataType &&\n      this.tensorShape.length === shape.length &&\n      this.tensorShape.every((v, i) => v === shape[i])\n    );\n  }\n\n  public setIsDataConverted(isConverted: boolean): void {\n    this.isDataConverted = isConverted;\n  }\n}\n\n/**\n * TensorTracker tracks the MLTensor and pending upload data.\n *\n * We need to track the MLTensor and pending upload data because we delay the creation of MLTensor until\n * we know the data type and shape. This is because WebNN only support creating MLTensors with dataTypes and shape.\n */\nclass TensorIdTracker {\n  private activeUpload?: Uint8Array;\n\n  constructor(\n    private tensorManager: TensorManagerImpl,\n    private wrapper?: TensorWrapper,\n  ) {}\n\n  public get tensorWrapper(): TensorWrapper | undefined {\n    return this.wrapper;\n  }\n\n  public releaseTensor(): void {\n    if (this.tensorWrapper) {\n      this.tensorManager.releaseTensor(this.tensorWrapper);\n      this.wrapper = undefined;\n    }\n  }\n\n  public async ensureTensor(\n    sessionId: number,\n    dataType: MLOperandDataType,\n    shape: readonly number[],\n    copyOld: boolean,\n  ): Promise<MLTensor> {\n    const context = this.tensorManager.getMLContext(sessionId);\n    const opLimits = this.tensorManager.getMLOpSupportLimits(sessionId);\n    let fallbackDataType: MLOperandDataType | undefined;\n    // Check if the context supports the data type. If not, try to use the fallback data type.\n    if (!opLimits?.input.dataTypes.includes(dataType)) {\n      fallbackDataType = webnnDataTypeToFallback.get(dataType);\n      if (!fallbackDataType || opLimits?.input.dataTypes.includes(fallbackDataType)) {\n        throw new Error(`WebNN backend does not support data type: ${dataType}`);\n      }\n      LOG_DEBUG(\n        'verbose',\n        () => `[WebNN] TensorIdTracker.ensureTensor: fallback dataType from ${dataType} to ${fallbackDataType}`,\n      );\n    }\n\n    if (this.wrapper) {\n      if (this.wrapper.canReuseTensor(context, dataType, shape)) {\n        return this.wrapper.tensor;\n      } else {\n        if (copyOld) {\n          if (this.wrapper.byteLength !== calculateByteLength(dataType, shape)) {\n            throw new Error('Unable to copy data to tensor with different size.');\n          }\n          this.activeUpload = new Uint8Array(await this.wrapper.read());\n        }\n        this.tensorManager.releaseTensor(this.wrapper);\n      }\n    }\n\n    // eslint-disable-next-line no-bitwise\n    const usage = typeof MLTensorUsage == 'undefined' ? undefined : MLTensorUsage.READ | MLTensorUsage.WRITE;\n    this.wrapper = await this.tensorManager.getCachedTensor(\n      sessionId,\n      dataType,\n      shape,\n      usage,\n      true,\n      true,\n      fallbackDataType,\n    );\n\n    if (copyOld && this.activeUpload) {\n      // We don't need to convert the original integer data to int32,\n      // because it has been converted when it was uploaded.\n      this.wrapper.write(this.activeUpload);\n      this.activeUpload = undefined;\n    }\n\n    return this.wrapper.tensor;\n  }\n\n  public upload(data: Uint8Array): void {\n    let newData = data;\n    if (this.wrapper) {\n      if (this.wrapper.fallbackType) {\n        if (this.wrapper.fallbackType === 'int32') {\n          // Convert original integer data to int32.\n          newData = convertDataToInt32(data, this.wrapper.type);\n          this.wrapper.setIsDataConverted(true);\n        } else {\n          throw new Error(`Unsupported fallback data type: ${this.wrapper.fallbackType}`);\n        }\n      }\n\n      // Check if the data size matches the tensor size.\n      if (data.byteLength === this.wrapper.byteLength) {\n        // Write the newData to the tensor.\n        this.wrapper.write(newData);\n        return;\n      } else {\n        LOG_DEBUG('verbose', () => 'Data size does not match tensor size. Releasing tensor.');\n        this.releaseTensor();\n      }\n    }\n\n    if (this.activeUpload) {\n      this.activeUpload.set(newData);\n    } else {\n      this.activeUpload = new Uint8Array(newData);\n    }\n  }\n\n  public async download(dstBuffer?: ArrayBufferView | ArrayBuffer): Promise<ArrayBuffer | undefined> {\n    if (this.activeUpload) {\n      // If this.activeUpload has been converted to int32, we need to convert it back to original integer data type.\n      const dstData = this.wrapper?.isDataConverted\n        ? convertInt32ToData(this.activeUpload, this.wrapper?.type)\n        : this.activeUpload;\n\n      if (dstBuffer) {\n        if (dstBuffer instanceof ArrayBuffer) {\n          new Uint8Array(dstBuffer).set(dstData);\n        } else {\n          new Uint8Array(dstBuffer.buffer, dstBuffer.byteOffset, dstBuffer.byteLength).set(dstData);\n        }\n        return;\n      } else {\n        return dstData.buffer;\n      }\n    }\n    if (!this.wrapper) {\n      throw new Error('Tensor has not been created.');\n    }\n\n    if (!dstBuffer) {\n      return this.wrapper.read();\n    }\n    return this.wrapper.read(dstBuffer);\n  }\n}\n\nclass TensorManagerImpl implements TensorManager {\n  private tensorTrackersById: Map<TensorId, TensorIdTracker> = new Map();\n  private freeTensors: TensorWrapper[] = [];\n  private externalTensors: Set<TensorWrapper> = new Set();\n\n  constructor(private backend: WebNNBackend) {}\n\n  public getMLContext(sessionId: number): MLContext {\n    const context = this.backend.getMLContext(sessionId);\n    if (!context) {\n      throw new Error('MLContext not found for session.');\n    }\n    return context;\n  }\n\n  public getMLOpSupportLimits(sessionId: number): MLOpSupportLimits | undefined {\n    return this.backend.getMLOpSupportLimits(sessionId);\n  }\n\n  public reserveTensorId(): TensorId {\n    const tensorId = createNewTensorId();\n    this.tensorTrackersById.set(tensorId, new TensorIdTracker(this));\n    return tensorId;\n  }\n\n  public releaseTensorId(tensorId: TensorId): void {\n    const tensorTracker = this.tensorTrackersById.get(tensorId);\n    if (!tensorTracker) {\n      return;\n    }\n    this.tensorTrackersById.delete(tensorId);\n    if (tensorTracker.tensorWrapper) {\n      this.releaseTensor(tensorTracker.tensorWrapper);\n    }\n  }\n\n  public async ensureTensor(\n    sessionId: number,\n    tensorId: TensorId,\n    dataType: MLOperandDataType,\n    shape: number[],\n    copyOld: boolean,\n  ): Promise<MLTensor> {\n    LOG_DEBUG(\n      'verbose',\n      () =>\n        `[WebNN] TensorManager.ensureTensor {tensorId: ${tensorId}, dataType: ${\n          dataType\n        }, shape: ${shape}, copyOld: ${copyOld}}`,\n    );\n    const tensor = this.tensorTrackersById.get(tensorId);\n    if (!tensor) {\n      throw new Error('Tensor not found.');\n    }\n    return tensor.ensureTensor(sessionId, dataType, shape, copyOld);\n  }\n\n  public upload(tensorId: TensorId, data: Uint8Array): void {\n    const tensor = this.tensorTrackersById.get(tensorId);\n    if (!tensor) {\n      throw new Error('Tensor not found.');\n    }\n    tensor.upload(data);\n  }\n\n  public async download(tensorId: TensorId): Promise<ArrayBuffer>;\n  public async download(tensorId: TensorId, dstBuffer: ArrayBufferView | ArrayBuffer): Promise<undefined>;\n  async download(tensorId: TensorId, dstBuffer?: ArrayBufferView | ArrayBuffer): Promise<ArrayBuffer | undefined> {\n    LOG_DEBUG(\n      'verbose',\n      () => `[WebNN] TensorManager.download {tensorId: ${tensorId}, dstBuffer: ${dstBuffer?.byteLength}}`,\n    );\n    const tensorTracker = this.tensorTrackersById.get(tensorId);\n    if (!tensorTracker) {\n      throw new Error('Tensor not found.');\n    }\n    return tensorTracker.download(dstBuffer);\n  }\n\n  public releaseTensorsForSession(sessionId: number): void {\n    for (const tensor of this.freeTensors) {\n      if (tensor.sessionId === sessionId) {\n        tensor.destroy();\n      }\n    }\n    this.freeTensors = this.freeTensors.filter((tensor) => tensor.sessionId !== sessionId);\n  }\n\n  public registerTensor(\n    sessionId: number,\n    mlTensor: MLTensor,\n    dataType: MLOperandDataType,\n    shape: readonly number[],\n  ): TensorId {\n    const context = this.getMLContext(sessionId);\n    const tensorId = createNewTensorId();\n    // Defaulting to READ | WRITE if usage is not provided.\n    const wrapper = new TensorWrapper({\n      sessionId,\n      context,\n      tensor: mlTensor,\n      dataType,\n      shape,\n    });\n    this.tensorTrackersById.set(tensorId, new TensorIdTracker(this, wrapper));\n    this.externalTensors.add(wrapper);\n    return tensorId;\n  }\n\n  /**\n   * Get or create an MLTensor with the given data type and shape.\n   */\n  public async getCachedTensor(\n    sessionId: number,\n    dataType: MLOperandDataType,\n    shape: readonly number[],\n    usage: MLTensorUsageFlags | undefined,\n    writable: boolean,\n    readable: boolean,\n    fallbackDataType?: MLOperandDataType,\n  ): Promise<TensorWrapper> {\n    const context = this.getMLContext(sessionId);\n    for (const [index, tensor] of this.freeTensors.entries()) {\n      if (tensor.canReuseTensor(context, dataType, shape)) {\n        LOG_DEBUG(\n          'verbose',\n          () =>\n            `[WebNN] Reusing tensor {dataType: ${dataType}, ${\n              fallbackDataType ? `fallbackDataType: ${fallbackDataType},` : ''\n            } shape: ${shape}`,\n        );\n        const wrapper = this.freeTensors.splice(index, 1)[0];\n        wrapper.sessionId = sessionId;\n        return wrapper;\n      }\n    }\n    LOG_DEBUG(\n      'verbose',\n      () =>\n        `[WebNN] MLContext.createTensor {dataType: ${dataType}, ${\n          fallbackDataType ? `fallbackDataType: ${fallbackDataType},` : ''\n        } shape: ${shape}}`,\n    );\n    const tensor = await context.createTensor({\n      dataType: fallbackDataType ?? dataType, // If fallback data type is provided, use it.\n      shape,\n      dimensions: shape,\n      usage,\n      writable,\n      readable,\n    });\n    return new TensorWrapper({ sessionId, context, tensor, dataType, shape, fallbackDataType });\n  }\n\n  /**\n   * Release tensor for reuse unless external.\n   */\n  public releaseTensor(tensorWrapper: TensorWrapper) {\n    if (this.externalTensors.has(tensorWrapper)) {\n      this.externalTensors.delete(tensorWrapper);\n    }\n    this.freeTensors.push(tensorWrapper);\n  }\n}\n\nexport const createTensorManager = (...args: ConstructorParameters<typeof TensorManagerImpl>): TensorManager =>\n  new TensorManagerImpl(...args);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// WebNN API currently does not have a TypeScript definition file. This file is a workaround with types generated from\n// WebNN API specification.\n// https://github.com/webmachinelearning/webnn/issues/677\n/// <reference path=\"webnn/webnn.d.ts\" />\n\nimport { Env, Tensor } from 'onnxruntime-common';\n\nimport { DataType, tensorDataTypeStringToEnum } from '../wasm-common';\nimport { getInstance } from '../wasm-factory';\n\nimport { createView } from './tensor-view';\nimport { TensorId, createTensorManager, convertDataToInt32 } from './webnn/tensor-manager';\nimport { configureLogger, LOG_DEBUG } from './log';\n\n/*\n * TensorProto::data_type to WebNN OperandType mapping.\n */\nconst onnxDataTypeToWebnnDataType = new Map<DataType, MLOperandDataType>([\n  [DataType.float, 'float32'],\n  [DataType.float16, 'float16'],\n  [DataType.int32, 'int32'],\n  [DataType.uint32, 'uint32'],\n  [DataType.int64, 'int64'],\n  [DataType.uint64, 'uint64'],\n  [DataType.int4, 'int4'],\n  [DataType.uint4, 'uint4'],\n  [DataType.int8, 'int8'],\n  [DataType.uint8, 'uint8'],\n  [DataType.bool, 'uint8'],\n]);\n\ntype MLContextEntry = {\n  gpuDevice?: GPUDevice;\n  options?: MLContextOptions;\n  mlContext: MLContext;\n};\n\nconst compareMLContextOptions = (a?: MLContextOptions, b?: MLContextOptions): boolean => {\n  if (a === b) {\n    return true;\n  }\n  if (a === undefined || b === undefined) {\n    return false;\n  }\n  const aKeys = Object.keys(a).sort() as Array<keyof typeof a>;\n  const bKeys = Object.keys(b).sort() as Array<keyof typeof b>;\n  return aKeys.length === bKeys.length && aKeys.every((key, index) => key === bKeys[index] && a[key] === b[key]);\n};\n\n/**\n * WebNN backend implementation. This class is used to keep track of the MLTensors created by the backend and keep track\n * of the current MLContext being used by the sessions.\n */\nexport class WebNNBackend {\n  /**\n   * Tensor managers for each session.\n   */\n  private tensorManager = createTensorManager(this);\n  /**\n   * Maps from session id to MLContexts.\n   */\n  private mlContextBySessionId = new Map<number, MLContext>();\n  /**\n   * Maps from MLContext to session ids.\n   */\n  private sessionIdsByMLContext = new Map<MLContext, Set<number>>();\n  /**\n   * Cache of MLContexts.\n   */\n  private mlContextCache: MLContextEntry[] = [];\n  /**\n   * Current session id.\n   */\n  private activeSessionId?: number;\n  /**\n   * Maps from session id to list of graph inputs.\n   */\n  private sessionGraphInputs: Map<number, string[]> = new Map();\n  /**\n   * Maps from session id to list of graph outputs.\n   */\n  private sessionGraphOutputs: Map<number, string[]> = new Map();\n  /**\n   * Temporary graph inputs for the current session.\n   * These inputs will be registered when the session is created.\n   */\n  private temporaryGraphInputs: string[] = [];\n  /**\n   * Temporary graph outputs for the current session.\n   * These outputs will be registered when the session is created.\n   */\n  private temporaryGraphOutputs: string[] = [];\n  /**\n   * Temporary tensors for the current session.\n   */\n  private temporarySessionTensorIds: Map<number, TensorId[]> = new Map();\n  /**\n   * Maps from session id to MLOpSupportLimits.\n   */\n  private mlOpSupportLimitsBySessionId = new Map<number, MLOpSupportLimits>();\n\n  constructor(env: Env) {\n    configureLogger(env.logLevel!, !!env.debug);\n  }\n\n  public get currentSessionId(): number {\n    if (this.activeSessionId === undefined) {\n      throw new Error('No active session');\n    }\n    return this.activeSessionId;\n  }\n\n  public onRunStart(sessionId: number): void {\n    LOG_DEBUG('verbose', () => `[WebNN] onRunStart {sessionId: ${sessionId}}`);\n    this.activeSessionId = sessionId;\n  }\n\n  public onRunEnd(sessionId: number): void {\n    LOG_DEBUG('verbose', () => `[WebNN] onRunEnd {sessionId: ${sessionId}}`);\n    const tensorIds = this.temporarySessionTensorIds.get(sessionId);\n    if (!tensorIds) {\n      return;\n    }\n    for (const tensorId of tensorIds) {\n      LOG_DEBUG('verbose', () => `[WebNN] releasing temporary tensor {tensorId: ${tensorId}}`);\n      this.tensorManager.releaseTensorId(tensorId);\n    }\n    this.temporarySessionTensorIds.delete(sessionId);\n    this.activeSessionId = undefined;\n  }\n\n  public async createMLContext(optionsOrDevice?: MLContextOptions | GPUDevice): Promise<MLContext> {\n    if (optionsOrDevice instanceof GPUDevice) {\n      const mlContextIndex = this.mlContextCache.findIndex((entry) => entry.gpuDevice === optionsOrDevice);\n      if (mlContextIndex !== -1) {\n        return this.mlContextCache[mlContextIndex].mlContext;\n      } else {\n        const mlContext = await navigator.ml.createContext(optionsOrDevice);\n        this.mlContextCache.push({ gpuDevice: optionsOrDevice, mlContext });\n        return mlContext;\n      }\n    } else if (optionsOrDevice === undefined) {\n      const mlContextIndex = this.mlContextCache.findIndex(\n        (entry) => entry.options === undefined && entry.gpuDevice === undefined,\n      );\n      if (mlContextIndex !== -1) {\n        return this.mlContextCache[mlContextIndex].mlContext;\n      } else {\n        const mlContext = await navigator.ml.createContext();\n        this.mlContextCache.push({ mlContext });\n        return mlContext;\n      }\n    }\n\n    const mlContextIndex = this.mlContextCache.findIndex((entry) =>\n      compareMLContextOptions(entry.options, optionsOrDevice),\n    );\n    if (mlContextIndex !== -1) {\n      return this.mlContextCache[mlContextIndex].mlContext;\n    } else {\n      const mlContext = await navigator.ml.createContext(optionsOrDevice);\n      this.mlContextCache.push({ options: optionsOrDevice, mlContext });\n      return mlContext;\n    }\n  }\n\n  public registerMLContext(sessionId: number, mlContext: MLContext): void {\n    this.mlContextBySessionId.set(sessionId, mlContext);\n    let sessionIds = this.sessionIdsByMLContext.get(mlContext);\n    if (!sessionIds) {\n      sessionIds = new Set();\n      this.sessionIdsByMLContext.set(mlContext, sessionIds);\n    }\n    sessionIds.add(sessionId);\n\n    if (!this.mlOpSupportLimitsBySessionId.has(sessionId)) {\n      this.mlOpSupportLimitsBySessionId.set(sessionId, mlContext.opSupportLimits());\n    }\n\n    if (this.temporaryGraphInputs.length > 0) {\n      this.sessionGraphInputs.set(sessionId, this.temporaryGraphInputs);\n      this.temporaryGraphInputs = [];\n    }\n    if (this.temporaryGraphOutputs.length > 0) {\n      this.sessionGraphOutputs.set(sessionId, this.temporaryGraphOutputs);\n      this.temporaryGraphOutputs = [];\n    }\n  }\n\n  public onReleaseSession(sessionId: number): void {\n    this.sessionGraphInputs.delete(sessionId);\n    this.sessionGraphOutputs.delete(sessionId);\n    const mlContext = this.mlContextBySessionId.get(sessionId)!;\n    if (!mlContext) {\n      // Current session is not a WebNN session.\n      return;\n    }\n    this.tensorManager.releaseTensorsForSession(sessionId);\n    this.mlContextBySessionId.delete(sessionId);\n    this.mlOpSupportLimitsBySessionId.delete(sessionId);\n    const sessionIds = this.sessionIdsByMLContext.get(mlContext)!;\n    sessionIds.delete(sessionId);\n    if (sessionIds.size === 0) {\n      this.sessionIdsByMLContext.delete(mlContext);\n      const mlContextIndex = this.mlContextCache.findIndex((entry) => entry.mlContext === mlContext);\n      if (mlContextIndex !== -1) {\n        this.mlContextCache.splice(mlContextIndex, 1);\n      }\n    }\n  }\n\n  public getMLContext(sessionId: number): MLContext | undefined {\n    return this.mlContextBySessionId.get(sessionId);\n  }\n\n  public getMLOpSupportLimits(sessionId: number): MLOpSupportLimits | undefined {\n    return this.mlOpSupportLimitsBySessionId.get(sessionId);\n  }\n\n  public reserveTensorId(): TensorId {\n    return this.tensorManager.reserveTensorId();\n  }\n\n  public releaseTensorId(tensorId: TensorId): void {\n    LOG_DEBUG('verbose', () => `[WebNN] releaseTensorId {tensorId: ${tensorId}}`);\n    this.tensorManager.releaseTensorId(tensorId);\n  }\n\n  public async ensureTensor(\n    sessionId: number | undefined,\n    tensorId: TensorId,\n    onnxDataType: DataType,\n    dimensions: number[],\n    copyOld: boolean,\n  ): Promise<MLTensor> {\n    const webnnDataType = onnxDataTypeToWebnnDataType.get(onnxDataType);\n    if (!webnnDataType) {\n      throw new Error(`Unsupported ONNX data type: ${onnxDataType}`);\n    }\n    return this.tensorManager.ensureTensor(\n      sessionId ?? this.currentSessionId,\n      tensorId,\n      webnnDataType,\n      dimensions,\n      copyOld,\n    );\n  }\n\n  public async createTemporaryTensor(\n    sessionId: number,\n    onnxDataType: DataType,\n    shape: readonly number[],\n  ): Promise<TensorId> {\n    LOG_DEBUG('verbose', () => `[WebNN] createTemporaryTensor {onnxDataType: ${onnxDataType}, shape: ${shape}}`);\n    const dataType = onnxDataTypeToWebnnDataType.get(onnxDataType);\n    if (!dataType) {\n      throw new Error(`Unsupported ONNX data type: ${onnxDataType}`);\n    }\n    const tensorId = this.tensorManager.reserveTensorId();\n    await this.tensorManager.ensureTensor(sessionId, tensorId, dataType, shape, false);\n    const tensorIds = this.temporarySessionTensorIds.get(sessionId);\n    if (!tensorIds) {\n      this.temporarySessionTensorIds.set(sessionId, [tensorId]);\n    } else {\n      tensorIds.push(tensorId);\n    }\n    return tensorId;\n  }\n\n  public uploadTensor(tensorId: TensorId, data: Uint8Array): void {\n    const wasm = getInstance();\n    if (!wasm.shouldTransferToMLTensor) {\n      throw new Error('Trying to upload to a MLTensor while shouldTransferToMLTensor is false');\n    }\n    LOG_DEBUG('verbose', () => `[WebNN] uploadTensor {tensorId: ${tensorId}, data: ${data.byteLength}}`);\n    this.tensorManager.upload(tensorId, data);\n  }\n\n  public async downloadTensor(tensorId: TensorId, dstBuffer: ArrayBufferView | ArrayBuffer): Promise<undefined> {\n    return this.tensorManager.download(tensorId, dstBuffer);\n  }\n\n  public createMLTensorDownloader(tensorId: TensorId, type: Tensor.MLTensorDataTypes): () => Promise<Tensor.DataType> {\n    return async () => {\n      const data = await this.tensorManager.download(tensorId);\n      return createView(data, type);\n    };\n  }\n\n  public registerMLTensor(sessionId: number, tensor: MLTensor, onnxDataType: DataType, dimensions: number[]): TensorId {\n    const webnnDataType = onnxDataTypeToWebnnDataType.get(onnxDataType);\n    if (!webnnDataType) {\n      throw new Error(`Unsupported ONNX data type: ${onnxDataType}`);\n    }\n\n    const id = this.tensorManager.registerTensor(sessionId, tensor, webnnDataType, dimensions);\n    LOG_DEBUG(\n      'verbose',\n      () =>\n        `[WebNN] registerMLTensor {tensor: ${tensor}, dataType: ${webnnDataType}, dimensions: ${\n          dimensions\n        }} -> {tensorId: ${id}}`,\n    );\n    return id;\n  }\n\n  // Register a WebNN Constant operand from external data.\n  public registerMLConstant(\n    externalFilePath: string,\n    dataOffset: number,\n    dataLength: number,\n    builder: MLGraphBuilder,\n    desc: MLOperandDescriptor,\n    mountedFiles: Map<string, Uint8Array> | undefined,\n    shouldConvertInt64ToInt32 = false,\n  ): MLOperand {\n    // If available, \"Module.MountedFiles\" is a Map for all preloaded files.\n    if (!mountedFiles) {\n      throw new Error('External mounted files are not available.');\n    }\n\n    let filePath = externalFilePath;\n    if (externalFilePath.startsWith('./')) {\n      filePath = externalFilePath.substring(2);\n    }\n    const fileData = mountedFiles.get(filePath);\n    if (!fileData) {\n      throw new Error(`File with name ${filePath} not found in preloaded files.`);\n    }\n\n    if (dataOffset + dataLength > fileData.byteLength) {\n      throw new Error('Out of bounds: data offset and length exceed the external file data size.');\n    }\n\n    const buffer = fileData.slice(dataOffset, dataOffset + dataLength).buffer;\n    let bufferView: ArrayBufferView;\n    switch (desc.dataType) {\n      case 'float32':\n        bufferView = new Float32Array(buffer);\n        break;\n      case 'float16':\n        bufferView =\n          typeof Float16Array !== 'undefined' && Float16Array.from ? new Float16Array(buffer) : new Uint16Array(buffer);\n        break;\n      case 'int32':\n        bufferView = new Int32Array(buffer);\n        break;\n      case 'uint32':\n        bufferView = new Uint32Array(buffer);\n        break;\n      case 'int64':\n        if (shouldConvertInt64ToInt32) {\n          // Int64 is not supported by current context, use int32 instead.\n          const int32Buffer = convertDataToInt32(new Uint8Array(buffer), 'int64');\n          bufferView = new Int32Array(int32Buffer.buffer);\n          desc.dataType = 'int32';\n        } else {\n          bufferView = new BigInt64Array(buffer);\n        }\n        break;\n      case 'uint64':\n        bufferView = new BigUint64Array(buffer);\n        break;\n      case 'int8':\n        bufferView = new Int8Array(buffer);\n        break;\n      case 'int4':\n      case 'uint4':\n      case 'uint8':\n        bufferView = new Uint8Array(buffer);\n        break;\n      default:\n        throw new Error(`Unsupported data type: ${desc.dataType} in creating WebNN Constant from external data.`);\n    }\n\n    LOG_DEBUG(\n      'verbose',\n      () =>\n        `[WebNN] registerMLConstant {dataType: ${desc.dataType}, shape: ${desc.shape}}} ${\n          shouldConvertInt64ToInt32 ? '(Note: it was int64 data type and registered to int32 as workaround)' : ''\n        }`,\n    );\n\n    return builder.constant(desc, bufferView);\n  }\n\n  public registerGraphInput(inputName: string): void {\n    this.temporaryGraphInputs.push(inputName);\n  }\n\n  public registerGraphOutput(outputName: string): void {\n    this.temporaryGraphOutputs.push(outputName);\n  }\n\n  public isGraphInput(sessionId: number, inputName: string): boolean {\n    const inputNames = this.sessionGraphInputs.get(sessionId);\n    if (!inputNames) {\n      return false;\n    }\n    return inputNames.includes(inputName);\n  }\n\n  public isGraphOutput(sessionId: number, outputName: string): boolean {\n    const outputNames = this.sessionGraphOutputs.get(sessionId);\n    if (!outputNames) {\n      return false;\n    }\n    return outputNames.includes(outputName);\n  }\n\n  public isGraphInputOutputTypeSupported(sessionId: number, type: Tensor.Type, isInput = true): boolean {\n    const dataType = onnxDataTypeToWebnnDataType.get(tensorDataTypeStringToEnum(type));\n    const opLimits = this.mlOpSupportLimitsBySessionId.get(sessionId);\n\n    if (typeof dataType === 'undefined') {\n      return false;\n    }\n\n    if (isInput) {\n      return !!opLimits?.input.dataTypes.includes(dataType);\n    } else {\n      return !!opLimits?.output.dataTypes.includes(dataType);\n    }\n  }\n\n  public flush(): void {\n    // Unlike the WebGPU backend, the WebNN backend does not need to flush any pending operations.\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../wasm-common';\nimport { TensorView } from '../tensor-view';\n\nimport { ShaderHelper } from './ops/common';\n\nexport type SessionState = 'default' | 'capturing' | 'replaying';\n\nexport enum GpuDataType {\n  default = 0,\n  upload = 1,\n  profile = 2,\n}\nexport type GpuDataId = number;\n\nexport type GpuArchitecture = 'ampere' | 'gen-12lp';\nexport type GpuVendor = 'amd' | 'intel' | 'nvidia';\nexport interface AdapterInfo {\n  isArchitecture: (architecture: GpuArchitecture) => boolean;\n  isVendor: (vendor: GpuVendor) => boolean;\n}\n\nexport interface GpuData {\n  type: GpuDataType;\n  id: GpuDataId;\n  buffer: GPUBuffer;\n}\n\nexport interface TensorInfo {\n  dims: readonly number[];\n  dataType: number;\n}\n\nexport interface ProgramUniform {\n  type: DataType;\n  data: number | readonly number[];\n}\n\nexport type ProgramUniformVariableInfo = [type: DataType, length: number];\n\n/**\n * Represent the dependency of a program on a specific input tensor.\n *\n * - 'none': the shader/uniform does not depend on this input's info\n * - 'type': the shader/uniform depends on data type of this input\n * - 'rank': the shader/uniform depends on data type and the rank of this input\n * - 'dims': the shader/uniform depends on data type and the dims of this input\n * - 'data': the shader/uniform depends on data type, the dims and the data of this input\n */\nexport type ProgramInputTensorInfoDependency = 'none' | 'type' | 'rank' | 'dims' | 'data';\n\n/**\n * Represent information about a program's cache for shader.\n */\nexport interface ProgramShaderCacheInfo {\n  /**\n   * an optional string as a cache hint in the artifact cache. If this is not specified, the cache hint will be empty.\n   *\n   * This hint string should only contains initializing-time information, such as the attributes or any information of\n   * initializers. It should NOT contain any runtime information, such as the shape of inputs.\n   */\n  hint?: string;\n\n  /**\n   * an optional list of dependencies of the program on the input tensors. If this is not specified, the program depends\n   * on 'dims' of all inputs.\n   */\n  inputDependencies?: ProgramInputTensorInfoDependency[];\n}\n\n/**\n * Represent information about a program's cache for uniform.\n */\nexport interface ProgramUniformCacheInfo {\n  /**\n   * an optional string as a cache hint in the uniform cache. If this is not specified, the cache hint will be empty.\n   *\n   * This hint string should only contains runtime information, such as the shape of inputs.\n   */\n  hint?: string;\n\n  /**\n   * an optional list of dependencies of the program on the input tensors. If this is not specified, the program depends\n   * on 'none' of all inputs.\n   */\n  inputDependencies?: ProgramInputTensorInfoDependency[];\n}\n\n/**\n * A set of data that represent a shader program\n */\nexport interface ProgramInfo {\n  /**\n   * the name of the program. used for debugging and profiling\n   */\n  name: string;\n\n  /**\n   * an optional object describing the cache information of the program shader.\n   *\n   * If this is not specified, assume hint is empty and inputDependencies are ['dims'] for all inputs.\n   */\n  shaderCache?: ProgramShaderCacheInfo;\n\n  /**\n   * the shader's processing source code.\n   *\n   * This function will be called when shader cache missed.\n   */\n  getShaderSource: (shaderHelper: ShaderHelper) => string;\n\n  /**\n   * A function to get run data required to run the program.\n   *\n   * This function will be called every time the program is executed. Should keep this function as simple as possible.\n   */\n  getRunData: (inputs: readonly TensorView[]) => {\n    outputs: readonly TensorInfo[];\n    dispatchGroup: { x: number; y?: number; z?: number };\n    programUniforms?: readonly ProgramUniform[];\n  };\n}\n\nexport interface Artifact {\n  programInfo: ProgramInfo;\n  computePipeline: GPUComputePipeline;\n  uniformVariablesInfo: readonly ProgramUniformVariableInfo[] | undefined;\n}\n\nexport interface ComputeContextInputsOutputsMapping {\n  /**\n   * specify the mapping to the program's inputs. the value can be a number or a tensor view.\n   * - if it's a number, it's the index of the kernel's input\n   * - if it's a tensor view, it's an existing tensor view that will be used as the input\n   *\n   * if inputs is not specified, the mapping will be the kernel's inputs in order.\n   */\n  readonly inputs?: ReadonlyArray<TensorView | number>;\n  /**\n   * specify the mapping to the program's outputs. the value must be a number.\n   * - if it's a non-negative number, it's the index of the kernel's output\n   * - if it's -1, it's an output that will be created as a temporary value. this value will be released after\n   * the kernel is executed.\n   * - if it's -2, it's an output that will be created as a persistent value. this value will be released when the\n   * kernel is released.\n   *\n   * if outputs is not specified, the mapping will be the kernel's outputs in order.\n   */\n  readonly outputs?: readonly number[];\n}\n\n/**\n * A ComputeContext instance carries the states that representing the current running of a kernel.\n */\nexport interface ComputeContext {\n  /**\n   * gpu adapter info\n   */\n  readonly adapterInfo: AdapterInfo;\n\n  /**\n   * stores the pointer to OpKernelContext\n   */\n  readonly opKernelContext: number;\n\n  /**\n   * a list of inputs, each input is an instance of TensorView\n   */\n  readonly inputs: readonly TensorView[];\n\n  /**\n   * a custom data object that can be used to store any data that is needed by the kernel\n   */\n  readonly kernelCustomData: { [key: string]: unknown };\n\n  /**\n   * a buffer that can be used to access custom data created each time the kernel is executed\n   */\n  readonly customDataBuffer: Uint8Array;\n\n  /**\n   * a number of outputs for the node\n   */\n  readonly outputCount: number;\n\n  compute(program: ProgramInfo, inputsOutputsMapping?: ComputeContextInputsOutputsMapping): TensorView[];\n  output(index: number, dims: readonly number[]): number;\n}\n\nexport type TimestampQuery = 'none' | 'inside-passes' | 'at-passes';\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { WebGpuBackend } from '../backend-webgpu';\nimport { LOG_DEBUG } from '../log';\n\nimport { GpuData, GpuDataId, GpuDataType } from './types';\n\n/**\n * manages GpuDataId -> GpuBuffer\n */\nexport interface GpuDataManager {\n  /**\n   * copy data from CPU to GPU.\n   */\n  upload(id: GpuDataId, data: Uint8Array): void;\n  /**\n   * copy data from GPU to GPU.\n   */\n  memcpy(sourceId: GpuDataId, destinationId: GpuDataId): void;\n  /**\n   * create new data on GPU.\n   */\n  create(size: number, usage?: number): GpuData;\n  /**\n   * get GPU data by ID.\n   */\n  get(id: GpuDataId): GpuData | undefined;\n  /**\n   * release the data on GPU by ID.\n   *\n   * @return size of the data released\n   */\n  release(id: GpuDataId): number;\n  /**\n   * copy data from GPU to CPU.\n   */\n  download(id: GpuDataId, getTargetBuffer: () => Uint8Array): Promise<void>;\n\n  /**\n   * refresh the buffers that marked for release.\n   *\n   * when release() is called, the buffer is not released immediately. this is because we need to wait for the commands\n   * to be submitted to the GPU. this function is called after the commands are submitted so that the buffers can be\n   * actually released.\n   */\n  refreshPendingBuffers(): void;\n\n  /**\n   * register an external buffer for IO Binding. If the buffer is already registered, return the existing GPU data ID.\n   *\n   * GPU data manager only manages a mapping between the buffer and the GPU data ID. It will not manage the lifecycle of\n   * the external buffer.\n   */\n  registerExternalBuffer(buffer: GPUBuffer, originalSize: number, previous?: [GpuDataId, GPUBuffer]): number;\n\n  /**\n   * unregister an external buffer for IO Binding.\n   */\n  unregisterExternalBuffer(id: GpuDataId): void;\n\n  /**\n   * destroy all gpu buffers.\n   */\n  dispose(): void;\n\n  /**\n   * create session related data.\n   */\n  onCreateSession(): void;\n\n  /**\n   * release session related data.\n   * @param sessionId - specify the session ID.\n   */\n  onReleaseSession(sessionId: number): void;\n}\n\ninterface StorageCacheValue {\n  gpuData: GpuData;\n  originalSize: number;\n}\n\nconst bucketFreelist: Map<number, number> = new Map([\n  [64, 250],\n  [128, 200],\n  [256, 200],\n  [512, 200],\n  [2048, 230],\n  [4096, 200],\n  [8192, 50],\n  [16384, 50],\n  [32768, 50],\n  [65536, 50],\n  [131072, 50],\n  [262144, 50],\n  [524288, 50],\n  [1048576, 50],\n  [2097152, 30],\n  [4194304, 20],\n  [8388608, 10],\n  [12582912, 10],\n  [16777216, 10],\n  [26214400, 15],\n  [33554432, 22],\n  [44236800, 2],\n  [58982400, 6],\n  // we don't want to cache the bucket sizes below but not caching them\n  // results in some major performance hits for models like sd-turbo.\n  [67108864, 6],\n  [134217728, 6],\n  [167772160, 6],\n]);\n\nconst bucketArr: number[] = [];\n\n/**\n * normalize the buffer size so that it fits the 128-bits (16 bytes) alignment.\n */\nconst calcNormalizedBufferSize = (size: number) => Math.ceil(Number(size) / 16) * 16;\n\n/**\n * calculate the buffer size so that it fits into buckets.\n */\nconst calcBucketBufferSize = (size: number) => {\n  for (let idx = 0; idx < bucketArr.length; idx++) {\n    const sizeForBucket = bucketArr[idx];\n    if (size <= sizeForBucket) {\n      return sizeForBucket;\n    }\n  }\n  // not in bucket list -> caller will not cache, round up to 16.\n  return Math.ceil(size / 16) * 16;\n};\n\nlet guid = 1;\nconst createNewGpuDataId = () => guid++;\n\n/**\n * exported standard download function. This function is used by the session to download the data from GPU, and also by\n * factory to create GPU tensors with the capacity of downloading data from GPU.\n *\n * @param backend - the WebGPU backend\n * @param gpuBuffer - the GPU buffer to download\n * @param originalSize - the original size of the data\n * @param getTargetBuffer - optional. If provided, the data will be copied to the target buffer. Otherwise, a new buffer\n * will be created and returned.\n */\nexport const downloadGpuData = async (\n  backend: WebGpuBackend,\n  gpuBuffer: GPUBuffer,\n  originalSize: number,\n  getTargetBuffer?: () => Uint8Array,\n): Promise<Uint8Array> => {\n  const bufferSize = calcNormalizedBufferSize(originalSize);\n  const gpuReadBuffer = backend.device.createBuffer(\n    // eslint-disable-next-line no-bitwise\n    { size: bufferSize, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ },\n  );\n  try {\n    const commandEncoder = backend.getCommandEncoder();\n    backend.endComputePass();\n    commandEncoder.copyBufferToBuffer(\n      gpuBuffer /* source buffer */,\n      0 /* source offset */,\n      gpuReadBuffer /* destination buffer */,\n      0 /* destination offset */,\n      bufferSize /* size */,\n    );\n    backend.flush();\n\n    await gpuReadBuffer.mapAsync(GPUMapMode.READ);\n\n    const arrayBuffer = gpuReadBuffer.getMappedRange();\n    if (getTargetBuffer) {\n      // if we already have a CPU buffer to accept the data, no need to clone the ArrayBuffer.\n      const targetBuffer = getTargetBuffer();\n      targetBuffer.set(new Uint8Array(arrayBuffer, 0, originalSize));\n      return targetBuffer;\n    } else {\n      // the mapped ArrayBuffer will be released when the GPU buffer is destroyed. Need to clone the\n      // ArrayBuffer.\n      return new Uint8Array(arrayBuffer.slice(0, originalSize));\n    }\n  } finally {\n    gpuReadBuffer.destroy();\n  }\n};\n\nclass GpuDataManagerImpl implements GpuDataManager {\n  // GPU Data ID => GPU Data ( storage buffer )\n  private storageCache: Map<GpuDataId, StorageCacheValue>;\n\n  // pending buffers for computing\n  private buffersPending: GPUBuffer[];\n\n  // The reusable storage buffers for computing.\n  private freeBuffers: Map<number, GPUBuffer[]>;\n  // The reusable uniform buffers\n  private freeUniformBuffers: Map<number, GPUBuffer[]>;\n\n  // The pendingBuffers for capture graph.\n  // a SessionID -> GPUBuffer[] mapping.\n  private capturedPendingBuffers: Map<number, GPUBuffer[]>;\n\n  // The session count.\n  private sessionCount: number;\n\n  constructor(private backend: WebGpuBackend) {\n    this.storageCache = new Map();\n    this.freeBuffers = new Map();\n    this.freeUniformBuffers = new Map();\n    this.buffersPending = [];\n    this.capturedPendingBuffers = new Map();\n\n    for (const [key] of bucketFreelist) {\n      bucketArr.push(key);\n      this.freeBuffers.set(key, []);\n      this.freeUniformBuffers.set(key, []);\n    }\n\n    this.sessionCount = 0;\n  }\n\n  upload(id: GpuDataId, data: Uint8Array): void {\n    const srcArrayBuffer = data.buffer;\n    const srcOffset = data.byteOffset;\n    const srcLength = data.byteLength;\n    const size = calcNormalizedBufferSize(srcLength);\n\n    // get destination gpu buffer\n    const gpuDataCache = this.storageCache.get(id);\n    if (!gpuDataCache) {\n      throw new Error('gpu data for uploading does not exist');\n    }\n    if (Number(gpuDataCache.originalSize) !== srcLength) {\n      throw new Error(`inconsistent data size. gpu data size=${gpuDataCache.originalSize}, data size=${srcLength}`);\n    }\n\n    // create gpu buffer\n    const gpuBufferForUploading = this.backend.device.createBuffer(\n      // eslint-disable-next-line no-bitwise\n      { mappedAtCreation: true, size, usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC },\n    );\n\n    // copy (upload) data\n    const arrayBuffer = gpuBufferForUploading.getMappedRange();\n    new Uint8Array(arrayBuffer).set(new Uint8Array(srcArrayBuffer, srcOffset, srcLength));\n    gpuBufferForUploading.unmap();\n\n    // GPU copy\n    const commandEncoder = this.backend.device.createCommandEncoder();\n    commandEncoder.copyBufferToBuffer(gpuBufferForUploading, 0, gpuDataCache.gpuData.buffer, 0, size);\n    this.backend.device.queue.submit([commandEncoder.finish()]);\n    gpuBufferForUploading.destroy();\n\n    LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.upload(id=${id})`);\n  }\n\n  memcpy(sourceId: GpuDataId, destinationId: GpuDataId): void {\n    // get source gpu buffer\n    const sourceGpuDataCache = this.storageCache.get(sourceId);\n    if (!sourceGpuDataCache) {\n      throw new Error('source gpu data for memcpy does not exist');\n    }\n    // get destination gpu buffer\n    const destinationGpuDataCache = this.storageCache.get(destinationId);\n    if (!destinationGpuDataCache) {\n      throw new Error('destination gpu data for memcpy does not exist');\n    }\n    if (sourceGpuDataCache.originalSize !== destinationGpuDataCache.originalSize) {\n      throw new Error('inconsistent source and destination gpu data size');\n    }\n\n    const size = calcNormalizedBufferSize(sourceGpuDataCache.originalSize);\n\n    // GPU copy\n    const commandEncoder = this.backend.getCommandEncoder();\n    this.backend.endComputePass();\n    commandEncoder.copyBufferToBuffer(\n      sourceGpuDataCache.gpuData.buffer,\n      0,\n      destinationGpuDataCache.gpuData.buffer,\n      0,\n      size,\n    );\n  }\n\n  registerExternalBuffer(buffer: GPUBuffer, originalSize: number, previous?: [GpuDataId, GPUBuffer]): number {\n    let id: number | undefined;\n    if (previous) {\n      id = previous[0];\n      if (buffer === previous[1]) {\n        LOG_DEBUG(\n          'verbose',\n          () =>\n            `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${id}, buffer is the same, skip.`,\n        );\n        return id;\n      } else if (this.backend.capturedCommandList.has(this.backend.currentSessionId!)) {\n        throw new Error(`Registering a different external buffer under graph capture mode is not supported yet.\n             Please use the previous external buffer!`);\n      }\n    } else {\n      id = createNewGpuDataId();\n    }\n\n    this.storageCache.set(id, { gpuData: { id, type: GpuDataType.default, buffer }, originalSize });\n    LOG_DEBUG(\n      'verbose',\n      () => `[WebGPU] GpuDataManager.registerExternalBuffer(size=${originalSize}) => id=${id}, registered.`,\n    );\n    return id;\n  }\n\n  unregisterExternalBuffer(id: GpuDataId): void {\n    if (id !== undefined) {\n      this.storageCache.delete(id);\n      LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.unregisterExternalBuffer() => id=${id}`);\n    }\n  }\n\n  // eslint-disable-next-line no-bitwise\n  create(size: number, usage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST): GpuData {\n    const bufferSize = calcBucketBufferSize(size);\n\n    let gpuBuffer;\n    // Currently, only storage buffers are reused.\n    // eslint-disable-next-line no-bitwise\n    const isStorage = (usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE;\n    // eslint-disable-next-line no-bitwise\n    const isUniform = (usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM;\n    if (isStorage || isUniform) {\n      const freeBuffers = isStorage ? this.freeBuffers : this.freeUniformBuffers;\n      const buffers = freeBuffers.get(bufferSize);\n      if (!buffers) {\n        // no such bucket/freelist - create gpu buffer\n        gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage });\n      } else {\n        if (buffers.length > 0) {\n          // in freelist, use it\n          gpuBuffer = buffers.pop() as GPUBuffer;\n        } else {\n          // bucket empty, create gpu buffer\n          gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage });\n        }\n      }\n    } else {\n      // create gpu buffer\n      gpuBuffer = this.backend.device.createBuffer({ size: bufferSize, usage });\n    }\n\n    const gpuData = { id: createNewGpuDataId(), type: GpuDataType.default, buffer: gpuBuffer };\n    this.storageCache.set(gpuData.id, { gpuData, originalSize: Number(size) });\n\n    LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.create(size=${size}) => id=${gpuData.id}`);\n    return gpuData;\n  }\n\n  get(id: GpuDataId): GpuData | undefined {\n    return this.storageCache.get(id)?.gpuData;\n  }\n\n  release(idInput: GpuDataId): number {\n    const id = typeof idInput === 'bigint' ? Number(idInput) : idInput;\n    const cachedData = this.storageCache.get(id);\n    if (!cachedData) {\n      if (this.storageCache.size === 0) {\n        // cache was previously cleared, no need to release anything.\n        return 0;\n      } else {\n        throw new Error('releasing data does not exist');\n      }\n    }\n\n    LOG_DEBUG('verbose', () => `[WebGPU] GpuDataManager.release(id=${id}), gpuDataId=${cachedData.gpuData.id}`);\n\n    this.storageCache.delete(id);\n    this.buffersPending.push(cachedData.gpuData.buffer);\n    // cachedData.gpuData.buffer.destroy();\n\n    return cachedData.originalSize;\n  }\n\n  async download(id: GpuDataId, getTargetBuffer: () => Uint8Array): Promise<void> {\n    const cachedData = this.storageCache.get(Number(id));\n    if (!cachedData) {\n      throw new Error('data does not exist');\n    }\n    await downloadGpuData(this.backend, cachedData.gpuData.buffer, cachedData.originalSize, getTargetBuffer);\n  }\n\n  refreshPendingBuffers(): void {\n    if (this.buffersPending.length === 0) {\n      return;\n    }\n\n    if (this.backend.sessionStatus === 'default') {\n      for (const buffer of this.buffersPending) {\n        const maxInFreeList = bucketFreelist.get(buffer.size);\n\n        // eslint-disable-next-line no-bitwise\n        if ((buffer.usage & GPUBufferUsage.STORAGE) === GPUBufferUsage.STORAGE) {\n          // Put the pending buffer to freeBuffers list instead of really destroying it for buffer reusing.\n          const freelist = this.freeBuffers.get(buffer.size) || [];\n          if (maxInFreeList === undefined || freelist.length >= maxInFreeList) {\n            buffer.destroy();\n          } else {\n            freelist.push(buffer);\n          }\n          // eslint-disable-next-line no-bitwise\n        } else if ((buffer.usage & GPUBufferUsage.UNIFORM) === GPUBufferUsage.UNIFORM) {\n          // Put the pending buffer to freeUniformBuffers list instead of really destroying it for buffer reusing.\n          const freelist = this.freeUniformBuffers.get(buffer.size) || [];\n          if (maxInFreeList === undefined || freelist.length >= maxInFreeList) {\n            buffer.destroy();\n          } else {\n            freelist.push(buffer);\n          }\n        } else {\n          buffer.destroy();\n        }\n      }\n      this.buffersPending = [];\n    } else {\n      // Don't release intermediate tensors in non-default mode.\n      // TODO: reuse the storage buffers in non-default mode.\n      let capturedBuffers = this.capturedPendingBuffers.get(this.backend.currentSessionId!);\n      if (!capturedBuffers) {\n        capturedBuffers = [];\n        this.capturedPendingBuffers.set(this.backend.currentSessionId!, capturedBuffers);\n      }\n      for (const buffer of this.buffersPending) {\n        capturedBuffers.push(buffer);\n      }\n      this.buffersPending = [];\n    }\n  }\n\n  dispose() {\n    this.freeBuffers.forEach((buffers) => {\n      buffers.forEach((buffer) => {\n        buffer.destroy();\n      });\n    });\n    this.freeUniformBuffers.forEach((buffers) => {\n      buffers.forEach((buffer) => {\n        buffer.destroy();\n      });\n    });\n\n    this.storageCache.forEach((storage) => {\n      storage.gpuData.buffer.destroy();\n    });\n\n    this.capturedPendingBuffers.forEach((buffers) => {\n      buffers.forEach((buffer) => {\n        buffer.destroy();\n      });\n    });\n    this.storageCache = new Map();\n    this.freeBuffers = new Map();\n    this.freeUniformBuffers = new Map();\n    this.capturedPendingBuffers = new Map();\n  }\n\n  onCreateSession() {\n    this.sessionCount += 1;\n  }\n\n  onReleaseSession(sessionId: number) {\n    // release the captured pending buffers.\n    const pendingBuffers = this.capturedPendingBuffers.get(sessionId);\n    if (pendingBuffers) {\n      pendingBuffers.forEach((buffer) => {\n        buffer.destroy();\n      });\n      this.capturedPendingBuffers.delete(sessionId);\n    }\n\n    // release the storage cache if no active sessions.\n    this.sessionCount -= 1;\n    if (this.sessionCount === 0) {\n      LOG_DEBUG('warning', () => '[WebGPU] Clearing webgpu buffer cache');\n      this.storageCache.forEach((storage) => {\n        storage.gpuData.buffer.destroy();\n      });\n      this.storageCache = new Map();\n    }\n  }\n}\n\nexport const createGpuDataManager = (...args: ConstructorParameters<typeof GpuDataManagerImpl>): GpuDataManager =>\n  new GpuDataManagerImpl(...args);\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\n/**\n * create a new object from the given attribute, and add a cacheKey property to it\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 { DataType } from '../../../wasm-common';\nimport { ShapeUtil } from '../../util';\nimport { ProgramUniform, ProgramUniformVariableInfo } from '../types';\n\n/**\n * constant value for a workgroup size.\n *\n * We definitely can do further optimization in future, but for now we use 64.\n *\n * rule of thumb: Use [a workgroup size of] 64 unless you know what GPU you are targeting or that your workload\n *                needs something different.\n *\n * from: https://surma.dev/things/webgpu/\n **/\nexport const WORKGROUP_SIZE = 64;\n\ninterface IndicesHelperTypes {\n  /**\n   * WGSL type of indices expression\n   */\n  readonly indices: string;\n\n  /**\n   * WGSL type of a value\n   */\n  readonly value: string;\n\n  /**\n   * WGSL type of storage type representing a value\n   *\n   * This is usually the same to `value`, but for some type (eg. bool), we need to use `u32` as storage type for\n   * value type `vec4<bool>`\n   */\n  readonly storage: string;\n\n  /**\n   * tensor type as represented in TensorView\n   */\n  readonly tensor: number;\n}\n\n/**\n * A helper class for generating WGSL code for manipulating indices and data for a shader's input or output.\n *\n * This class is designed to offer a unified way to generate WGSL code for manipulating indices and data for a shader's\n * input or output.\n *\n * The following is a list of terminologies used in this class:\n * - `offset`: a uint32 value representing the offset of an element in the data buffer.\n * - `indices`: an abstraction of a multi-dimensional array's indices representing the data's index on each dimension.\n * - `value`: a value of a data element.\n *\n * Users are expected to create an instance of this class for each shader's input or output, and use the instance to\n * generate WGSL code for manipulating indices and data. The following 2 exported functions are for users to call to\n * create an instance of an indices helper:\n * - `inputVariable()`: create an indices helper instance for an input.\n * - `outputVariable()`: create an indices helper instance for an output.\n * - `internalVariable()`: create an indices helper instance for an internal variable.\n *\n * An indices helper instance contains helper functions for the following operations:\n * - access readonly basic information, including: `name`(the name of the input or output), `usage`(whether it's an\n * input, an output or an internal variable) and `shape`(the passed in shape).\n * - `type`: access readonly type information, including: `indices`(the type of indices), `value`(the type of value at\n * runtime), `storage`(the type of value at storage) and `tensor`(the tensor type as represented in TensorView).\n * - generate WGSL code for getting indices from offset. Use `offsetToIndices()` for WGSL code snippet to calculate\n * indices from offset, and use `indicesToOffset()` for WGSL code snippet to calculate offset from indices.\n * - to manipulate an instance of indices, use `setIndices()` and `getIndices()` to set and get the indices on an\n * indices variable.\n * - to manipulate data, use `set()`/`get()` to access data at the given indices from parameter list, use\n * `setByIndices()`/`getByIndices()` to access data at the given indices from an indices variable, and use\n * `setByOffset()`/`getByOffset()` to access data at the given offset.\n * - `impl`: get WGSL code of function implementation for the util functions mentioned above.\n */\nexport interface IndicesHelper {\n  /**\n   * get WGSL code of function implementation for the util functions.\n   *\n   */\n  readonly impl: () => string;\n\n  /**\n   * get type info\n   */\n  readonly type: IndicesHelperTypes;\n\n  /**\n   * WGSL code of a expression for getting indices from offset.\n   *\n   * @param varOffset - a u32 expression representing the offset.\n   *\n   * @returns an `type.indices` expression\n   */\n  readonly offsetToIndices: (varOffset: string) => string;\n\n  /**\n   * WGSL code of an `u32` expression for getting offset from indices.\n   *\n   * @param varIndices - a `type.indices` expression representing the indices.\n   *\n   * @returns an `u32` expression\n   */\n  readonly indicesToOffset: (varIndices: string) => string;\n\n  /**\n   * WGSL code of an `u32` expression for getting original offset from broadcasted indices.\n   *\n   * @param varIndices - a `type.indices` expression representing the output indices.\n   * @param output - output IndicesHelper.\n   *\n   * @returns an `u32` expression\n   */\n  readonly broadcastedIndicesToOffset: (varIndices: string, output: IndicesHelper) => string;\n\n  /**\n   * WGSL code of generating an indices literal\n   *\n   * @param init - initial value.\n   */\n  readonly indices: (...init: ReadonlyArray<number | string>) => string;\n\n  /**\n   * WGSL code of a statement for setting indices.\n   *\n   * @param varIndices - a variable name for the indices.\n   * @param idx - the index of the indices to set. can be a number or a string (WGSL `u32` expression).\n   * @param value - the value to set. can be a number or a string (WGSL `u32` expression).\n   *\n   * @returns a WGSL statement\n   */\n  readonly indicesSet: (varIndices: string, idx: number | string, value: number | string) => void;\n\n  /**\n   * WGSL code of an `u32` expression for getting indices.\n   *\n   * @param varIndices - a variable name for the indices.\n   * @param idx - the index of the indices to get. can be a number or a string (WGSL `u32` expression).\n   *\n   * @returns an `u32` expression\n   */\n  readonly indicesGet: (varIndices: string, idx: number | string) => string;\n\n  /**\n   * WGSL code for a statement for setting data at the given indices.\n   *\n   * @param indicesAndValue - an array of numbers or strings (WGSL `u32` expression) representing the indices, followed\n   *     by the value to set. This array should have exactly `shape.length + 1` elements.\n   */\n  readonly set: (...indicesAndValue: ReadonlyArray<number | string>) => string;\n\n  /**\n   * WGSL code for a statement for setting data at the given indices variable.\n   *\n   * @param varIndices - a variable name for the indices.\n   * @param value - the value to set. should be a WGSL expression.\n   */\n  readonly setByIndices: (varIndices: string, value: string) => string;\n\n  /**\n   * WGSL code for a statement for setting data at the given offset.\n   *\n   * @param offset - a number or a string (WGSL `u32` expression) representing the offset.\n   * @param value - the value to set. should be a WGSL expression.\n   */\n  readonly setByOffset: (offset: number | string, value: string) => string;\n\n  /**\n   * WGSL code for an expression for getting data at the given indices.\n   *\n   * @param indices - an array of numbers or strings (WGSL `u32` expression) representing the indices.\n   */\n  readonly get: (...indices: ReadonlyArray<number | string>) => string;\n\n  /**\n   * WGSL code for an expression for getting data at the given indices variable.\n   *\n   * @param varIndices - a variable name for the indices.\n   */\n  readonly getByIndices: (varIndices: string) => string;\n\n  /**\n   * WGSL code for an expression for getting data at the given offset.\n   *\n   * @param offset - a number or a string (WGSL `u32` expression) representing the offset.\n   */\n  readonly getByOffset: (offset: number | string) => string;\n\n  /**\n   * name of the data variable\n   */\n  readonly name: string;\n\n  /**\n   * whether the helper is for an input, an output or an internal variable.\n   */\n  readonly usage: 'input' | 'output' | 'atomicOutput' | 'internal';\n\n  /**\n   * the rank of the input or output.\n   */\n  readonly rank: number;\n\n  /**\n   * a string representing the variable name for the shape of the input or output.\n   */\n  readonly shape: string;\n\n  /**\n   * a string representing the variable name for the strides of the input or output.\n   */\n  readonly strides: string;\n}\n\nconst getWgslMappedType = (type: number, components: 1 | 2 | 3 | 4): string | [string, string] => {\n  if (components === 3) {\n    throw new Error('vec3 has same alignment as vec4, use vec4 instead');\n  }\n\n  // return type is [ storage type, runtime type ] or a single string for both\n  switch (Number(type)) {\n    case DataType.float16:\n      return components > 1 ? `vec${components}<f16>` : 'f16';\n    case DataType.float:\n      return components > 1 ? `vec${components}<f32>` : 'f32';\n    case DataType.int32:\n      return components > 1 ? `vec${components}<i32>` : 'i32';\n    case DataType.uint32:\n      return components > 1 ? `vec${components}<u32>` : 'u32';\n    case DataType.int64:\n      if (components > 1) {\n        throw new Error('currently not supported vecX of uint64 yet');\n      }\n      return ['vec2<u32>', 'i32'];\n    case DataType.uint64:\n      if (components > 1) {\n        throw new Error('currently not supported vecX of uint64 yet');\n      }\n      return ['vec2<u32>', 'u32'];\n    case DataType.bool:\n      if (components !== 4) {\n        throw new Error('bool must be vec4');\n      }\n      return ['u32', 'vec4<bool>'];\n    case DataType.int4:\n      return 'i32';\n    case DataType.uint4:\n      return 'u32';\n    default:\n      throw new Error(`Unknown data type: ${type}`);\n  }\n};\n\nexport const tensorTypeToWsglStorageType = (type: DataType, components: 1 | 2 | 3 | 4 = 1) => {\n  const mappedType = getWgslMappedType(type, components);\n  return typeof mappedType === 'string' ? mappedType : mappedType[0];\n};\n\nexport const tensorTypeToWsglValueType = (type: DataType, components: 1 | 2 | 3 | 4 = 1) => {\n  const mappedType = getWgslMappedType(type, components);\n  return typeof mappedType === 'string' ? mappedType : mappedType[1];\n};\n\nexport const createTensorShapeVariables = (...dims: ReadonlyArray<readonly number[]>): ProgramUniform[] => {\n  const programUniforms: ProgramUniform[] = [];\n  dims.forEach((dim) => {\n    if (dim.length !== 0) {\n      programUniforms.push(\n        { type: DataType.uint32, data: dim },\n        { type: DataType.uint32, data: ShapeUtil.computeStrides(dim) },\n      );\n    }\n  });\n  return programUniforms;\n};\n\n/**\n * A helper function to get maximum vector size for specified data length\n * @param size\n */\nexport const getMaxComponents = (size: number) => {\n  // we cannot use vec3 type since it has alignment of 16 bytes\n  if (size % 4 === 0) {\n    return 4;\n  } else if (size % 2 === 0) {\n    return 2;\n  }\n\n  return 1;\n};\n\n/**\n * A helper function that initializes variable as a scalar or vector. e.g. f32(0) or vec4f(0,0,0,0)\n * @param dataType\n * @param components\n * @param value\n */\nexport const fillVector = (dataType = 'f32', components?: number, value = '0') => {\n  if (!components || components === 1) {\n    return `${dataType}(${value})`;\n  }\n\n  return `vec${components}<${dataType}>(${value})`;\n};\n\n/**\n * A helper function that casts value or vector to f32\n * @param dataType\n * @param components\n * @param value\n */\nexport const castToF32 = (dataType: string, components: number, value: string) => {\n  if (dataType === 'f32') {\n    return value;\n  }\n  if (components === 1) {\n    return `f32(${value})`;\n  }\n\n  return `vec${components}<f32>(${value})`;\n};\n\n/**\n * A helper function that returns scalar or sums all components of a vector\n * @param name\n * @param components\n */\nexport const sumVector = (name: string, components: number) => {\n  if (components === 4) {\n    return `(${name}.x + ${name}.y + ${name}.z + ${name}.w)`;\n  } else if (components === 2) {\n    return `(${name}.x + ${name}.y)`;\n  } else if (components === 3) {\n    return `(${name}.x + ${name}.y + ${name}.z)`;\n  }\n\n  return name;\n};\n\n/**\n * A helper function that returns variable element at index.\n * @param name - the name of variable.\n * @param index - the index of variable element.\n * @param length - the length of variable.\n * @param type - the type of variable, optional.\n */\nexport const getElementAt = (\n  name: string,\n  index: number | string,\n  length: number,\n  type?: UniformDataElementType,\n): string => {\n  if (name.startsWith('uniforms.') && length > 4) {\n    if (typeof index === 'string') {\n      if (type === 'f16') {\n        return `${name}[(${index}) / 8][(${index}) % 8 / 4][(${index}) % 8 % 4]`;\n      } else {\n        return `${name}[(${index}) / 4][(${index}) % 4]`;\n      }\n    } else {\n      if (type === 'f16') {\n        return `${name}[${Math.floor(index / 8)}][${Math.floor((index % 8) / 4)}][${(index % 8) % 4}]`;\n      } else {\n        return `${name}[${Math.floor(index / 4)}][${index % 4}]`;\n      }\n    }\n  } else {\n    return length > 1 ? `${name}[${index}]` : name;\n  }\n};\n\n/**\n * A helper function to get a IndicesHelper for a given input or output.\n *\n * @param name - the name of the input or output.\n * @param tensorType - the tensor type of the input or output.\n * @param shapeOrRank - the tensor shape or the rank of the input or output.\n * @param usage - the usage of the indices helper.\n * @param components - indicates the number of components of each element. 1 for scalar, 2 for vec2, 3 for vec3, 4 for\n *    vec4.\n */\nconst createIndicesHelper = (\n  name: string,\n  tensorType: number,\n  shapeOrRank: number | readonly number[],\n  usage: IndicesHelper['usage'],\n  components: 1 | 2 | 3 | 4,\n): IndicesHelper => {\n  const useUniform = typeof shapeOrRank === 'number';\n  const rank = useUniform ? shapeOrRank : shapeOrRank.length;\n  const rankIdentity = [...new Array(rank).keys()];\n  const indicesType = rank < 2 ? 'u32' : rank <= 4 ? `vec${rank}<u32>` : `array<u32, ${rank}>`;\n  const mappedType = getWgslMappedType(tensorType, components);\n  const valueType = typeof mappedType === 'string' ? mappedType : mappedType[1];\n  const storageType = typeof mappedType === 'string' ? mappedType : mappedType[0];\n  const type = { indices: indicesType, value: valueType, storage: storageType, tensor: tensorType };\n\n  const normalizeDim = (dim: number | string): string => (typeof dim === 'string' ? dim : `${dim}u`);\n\n  const implementationUsed = {\n    offsetToIndices: false,\n    indicesToOffset: false,\n    broadcastedIndicesToOffset: false,\n    set: false,\n    setByIndices: false,\n    get: false,\n    getByIndices: false,\n  };\n\n  const uniformPrefix = useUniform ? 'uniforms.' : '';\n  const shape = `${uniformPrefix}${name}_shape`;\n  const strides = `${uniformPrefix}${name}_strides`;\n\n  let o2iSnippet = '';\n  for (let i = 0; i < rank - 1; i++) {\n    o2iSnippet += `\n    let dim${i} = current / ${getElementAt(strides, i, rank)};\n    let rest${i} = current % ${getElementAt(strides, i, rank)};\n    indices[${i}] = dim${i};\n    current = rest${i};\n    `;\n  }\n  o2iSnippet += `indices[${rank - 1}] = current;`;\n\n  const offsetToIndicesImplementation =\n    rank < 2\n      ? ''\n      : `\n  fn o2i_${name}(offset: u32) -> ${type.indices} {\n    var indices: ${type.indices};\n    var current = offset;\n    ${o2iSnippet}\n    return indices;\n  }`;\n\n  const offsetToIndices = (varOffset: string) => {\n    implementationUsed.offsetToIndices = true;\n    return rank < 2 ? varOffset : `o2i_${name}(${varOffset})`;\n  };\n\n  const offsets: string[] = [];\n  if (rank >= 2) {\n    for (let i = rank - 1; i >= 0; i--) {\n      offsets.push(`${getElementAt(strides, i, rank)} * (indices[${i}])`);\n    }\n  }\n\n  const indicesToOffsetImplementation =\n    rank < 2\n      ? ''\n      : `\n  fn i2o_${name}(indices: ${type.indices}) -> u32 {\n    return ${offsets.join('+')};\n  }`;\n\n  const indicesToOffset = (varIndices: string) => {\n    implementationUsed.indicesToOffset = true;\n    return rank < 2 ? varIndices : `i2o_${name}(${varIndices})`;\n  };\n\n  const indices = (...init: ReadonlyArray<number | string>) =>\n    rank === 0 ? '0u' : `${type.indices}(${init.map(normalizeDim).join(',')})`;\n\n  const indicesGet = (varIndices: string, idx: number | string) => {\n    if (rank < 2) {\n      return `${varIndices}`;\n    } else {\n      return `${getElementAt(varIndices, idx, rank)}`;\n    }\n  };\n\n  const indicesSet = (varIndices: string, idx: number | string, value: string) => {\n    if (rank < 2) {\n      return `${varIndices}=${value};`;\n    } else {\n      return `${getElementAt(varIndices, idx, rank)}=${value};`;\n    }\n  };\n\n  const broadcastedIndicesToOffsetImplementation: { [key: string]: string } = {};\n  const broadcastedIndicesToOffset = (varIndices: string, output: IndicesHelper) => {\n    implementationUsed.broadcastedIndicesToOffset = true;\n    const implKey = `${output.name}broadcastedIndicesTo${name}Offset`;\n    if (implKey in broadcastedIndicesToOffsetImplementation) {\n      return `${implKey}(${varIndices})`;\n    }\n    const offsets = [];\n    for (let i = rank - 1; i >= 0; i--) {\n      const idx = output.indicesGet('outputIndices', i + output.rank - rank);\n      offsets.push(`${indicesGet(strides, i)} * (${idx} % ${indicesGet(shape, i)})`);\n    }\n    broadcastedIndicesToOffsetImplementation[implKey] = `fn ${implKey}(outputIndices: ${output.type.indices}) -> u32 {\n             return ${offsets.length > 0 ? offsets.join('+') : '0u'};\n           }`;\n\n    return `${implKey}(${varIndices})`;\n  };\n\n  const setByOffset = (offset: number | string, value: string) =>\n    (() => {\n      if (type.storage === type.value) {\n        return `${name}[${offset}]=${value};`;\n      } else if (type.storage === 'vec2<u32>' && type.value === 'i32') {\n        // int64, components === 1\n        return `${name}[${offset}]=vec2<u32>(u32(${value}), select(0u, 0xFFFFFFFFu, ${value} < 0));`;\n      } else if (type.storage === 'vec2<u32>' && type.value === 'u32') {\n        // uint64, components === 1\n        return `${name}[${offset}]=vec2<u32>(u32(${value}), 0u);`;\n      } else if (type.storage === 'u32' && type.value === 'vec4<bool>') {\n        // bool, components === 4\n        return `${name}[${offset}]=dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(${value}));`;\n      } else {\n        throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`);\n      }\n    })();\n\n  const getByOffset = (offset: number | string) =>\n    (() => {\n      if (type.storage === type.value) {\n        return `${name}[${offset}]`;\n      } else if (type.storage === 'vec2<u32>' && type.value === 'i32') {\n        // int64, components === 1\n        return `i32(${name}[${offset}].x)`;\n      } else if (type.storage === 'vec2<u32>' && type.value === 'u32') {\n        // uint64, components === 1\n        return `u32(${name}[${offset}].x)`;\n      } else if (type.storage === 'u32' && type.value === 'vec4<bool>') {\n        // bool, components === 4\n        return `vec4<bool>(bool(${name}[${offset}] & 0xFFu), bool(${name}[${offset}] & 0xFF00u), bool(${name}[${\n          offset\n        }] & 0xFF0000u), bool(${name}[${offset}] & 0xFF000000u))`;\n      } else {\n        throw new Error(`not supported combination of storage type ${type.storage} and value type ${type.value} yet`);\n      }\n    })();\n\n  const getByIndicesImplementation =\n    rank < 2\n      ? ''\n      : `\n  fn get_${name}ByIndices(indices: ${type.indices}) -> ${valueType} {\n    return ${getByOffset(`i2o_${name}(indices)`)};\n  }`;\n\n  const getImplementation =\n    rank < 2\n      ? ''\n      : (() => {\n          const functionParams = rankIdentity.map((i) => `d${i}: u32`).join(', ');\n          const dimsParams = rankIdentity.map((i) => `d${i}`).join(', ');\n          return `\n  fn get_${name}(${functionParams}) -> ${valueType} {\n    return get_${name}ByIndices(${indices(dimsParams)});\n  }`;\n        })();\n\n  const get = (...indices: ReadonlyArray<number | string>) => {\n    if (indices.length !== rank) {\n      throw new Error(`indices length must be ${rank}`);\n    }\n\n    const normalizedIndices = indices.map(normalizeDim).join(',');\n\n    if (rank === 0) {\n      return getByOffset('0u');\n    } else if (rank === 1) {\n      return getByOffset(normalizedIndices[0]);\n    } else {\n      implementationUsed.get = true;\n      implementationUsed.getByIndices = true;\n      implementationUsed.indicesToOffset = true;\n      return `get_${name}(${normalizedIndices})`;\n    }\n  };\n\n  const getByIndices = (varIndices: string) => {\n    if (rank < 2) {\n      return getByOffset(varIndices);\n    } else {\n      implementationUsed.getByIndices = true;\n      implementationUsed.indicesToOffset = true;\n      return `get_${name}ByIndices(${varIndices})`;\n    }\n  };\n\n  const setByIndicesImplementation =\n    rank < 2\n      ? ''\n      : `\n  fn set_${name}ByIndices(indices: ${type.indices}, value: ${valueType}) {\n    ${setByOffset(`i2o_${name}(indices)`, 'value')}\n  }`;\n\n  const setImplementation =\n    rank < 2\n      ? ''\n      : (() => {\n          const functionParams = rankIdentity.map((i) => `d${i}: u32`).join(', ');\n          const dimsParams = rankIdentity.map((i) => `d${i}`).join(', ');\n          return `\n  fn set_${name}(${functionParams}, value: ${valueType}) {\n    set_${name}ByIndices(${indices(dimsParams)}, value);\n  }`;\n        })();\n\n  const set = (...indicesAndValue: ReadonlyArray<number | string>) => {\n    if (indicesAndValue.length !== rank + 1) {\n      throw new Error(`indices length must be ${rank}`);\n    }\n    const value = indicesAndValue[rank];\n    if (typeof value !== 'string') {\n      throw new Error('value must be string');\n    }\n\n    const normalizedIndices = indicesAndValue.slice(0, rank).map(normalizeDim).join(',');\n\n    if (rank === 0) {\n      return setByOffset('0u', value);\n    } else if (rank === 1) {\n      return setByOffset(normalizedIndices[0], value);\n    } else {\n      implementationUsed.set = true;\n      implementationUsed.setByIndices = true;\n      implementationUsed.indicesToOffset = true;\n      return `set_${name}(${normalizedIndices}, ${value})`;\n    }\n  };\n\n  const setByIndices = (varIndices: string, value: string) => {\n    if (rank < 2) {\n      return setByOffset(varIndices, value);\n    } else {\n      implementationUsed.setByIndices = true;\n      implementationUsed.indicesToOffset = true;\n      return `set_${name}ByIndices(${varIndices}, ${value});`;\n    }\n  };\n\n  const impl = () => {\n    const impls = [];\n    let needShapeStrides = false;\n    if (implementationUsed.offsetToIndices) {\n      impls.push(offsetToIndicesImplementation);\n      needShapeStrides = true;\n    }\n    if (implementationUsed.indicesToOffset) {\n      impls.push(indicesToOffsetImplementation);\n      needShapeStrides = true;\n    }\n    if (implementationUsed.broadcastedIndicesToOffset) {\n      Object.values(broadcastedIndicesToOffsetImplementation).forEach((impl) => impls.push(impl));\n      needShapeStrides = true;\n    }\n    if (implementationUsed.set) {\n      impls.push(setImplementation);\n      needShapeStrides = true;\n    }\n    if (implementationUsed.setByIndices) {\n      impls.push(setByIndicesImplementation);\n      needShapeStrides = true;\n    }\n    if (implementationUsed.get) {\n      impls.push(getImplementation);\n      needShapeStrides = true;\n    }\n    if (implementationUsed.getByIndices) {\n      impls.push(getByIndicesImplementation);\n      needShapeStrides = true;\n    }\n    if (!useUniform && needShapeStrides) {\n      impls.unshift(\n        `const ${shape} = ${type.indices}(${shapeOrRank.join(',')});`,\n        `const ${strides} = ${type.indices}(${ShapeUtil.computeStrides(shapeOrRank).join(',')});`,\n      );\n    }\n    return impls.join('\\n');\n  };\n\n  return {\n    impl,\n    type,\n    offsetToIndices,\n    indicesToOffset,\n    broadcastedIndicesToOffset,\n    indices,\n    indicesGet,\n    indicesSet,\n    set,\n    setByOffset,\n    setByIndices,\n    get,\n    getByOffset,\n    getByIndices,\n    // isVec4,\n    usage,\n    name,\n    strides,\n    shape,\n    rank,\n  };\n};\n\n/**\n * Create a IndicesHelper for an input.\n *\n * @param name - the name of the input.\n * @param type - the tensor type of the input.\n * @param shapeOrRank - the tensor shape or the rank of the input.\n * @param components - the number of components of the input. available values are 1, 2, 3, 4. default is 1.\n * @returns an IndicesHelper for the input.\n */\nexport const inputVariable = (\n  name: string,\n  type: number,\n  shapeOrRank: number | readonly number[],\n  components: 1 | 2 | 3 | 4 = 1,\n): IndicesHelper => createIndicesHelper(name, type, shapeOrRank, 'input', components);\n\n/**\n * Create a IndicesHelper for an output.\n *\n * @param name - the name of the output.\n * @param type - the tensor type of the output.\n * @param shapeOrRank - the tensor shape or the rank of the output.\n * @param components - the number of components of the output. available values are 1, 2, 3, 4. default is 1.\n * @returns an IndicesHelper for the output.\n */\nexport const outputVariable = (\n  name: string,\n  type: number,\n  shapeOrRank: number | readonly number[],\n  components: 1 | 2 | 3 | 4 = 1,\n): IndicesHelper => createIndicesHelper(name, type, shapeOrRank, 'output', components);\n\n/**\n * Create a IndicesHelper for an atomic output.\n *\n * @param name - the name of the output.\n * @param type - the tensor type of the output.\n * @param shapeOrRank - the tensor shape or the rank of the output.\n * @returns an IndicesHelper for the output.\n */\nexport const atomicOutputVariable = (\n  name: string,\n  type: number,\n  shapeOrRank: number | readonly number[],\n): IndicesHelper => createIndicesHelper(name, type, shapeOrRank, 'atomicOutput', 1);\n\n/**\n * Create a IndicesHelper for an internal variable.\n *\n * @param name - the name of the variable.\n * @param type - the tensor type of the variable.\n * @param shapeOrRank - the tensor shape or the rank of the variable.\n * @param components - the number of components of the variable. available values are 1, 2, 3, 4. default is 1.\n * @returns an IndicesHelper for the variable.\n */\nexport const internalVariable = (\n  name: string,\n  type: number,\n  shapeOrRank: number | readonly number[],\n  components: 1 | 2 | 3 | 4 = 1,\n): IndicesHelper => createIndicesHelper(name, type, shapeOrRank, 'internal', components);\n\nexport type UniformDataElementType = 'u32' | 'f16' | 'f32' | 'i32';\nexport type UniformsArrayType = Array<{ name: string; type: UniformDataElementType; length?: number }>;\n\n/**\n * A ShaderHelper is a helper class for generating WGSL code.\n */\nexport interface ShaderHelper {\n  /**\n   * A helper function to generate the start of main function in WGSL source code.\n   *\n   * @example\n   * const getShaderSource = (shaderHelper: ShaderHelper) => `\n   *  ...\n   *\n   *  ${shaderHelper.mainStart()}\n   *    // your code here inside main() function\n   *    ...\n   *  }\n   * `;\n   *\n   * @param workgroupSize - an optional workgroup size. default is WORKGROUP_SIZE.\n   */\n  mainStart(workgroupSize?: number | [number, number, number]): string;\n\n  /**\n   * A helper function to generate the code snippet for guarding against out-of-bounds size.\n   *\n   * @example\n   * const getShaderSource = (shaderHelper: ShaderHelper) => `\n   *  ...\n   *\n   *  ${shaderHelper.mainStart()}\n   *    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n   *\n   *    // your code here inside main() function\n   *    ...\n   *  }\n   * `;\n   *\n   * @param size - the size of the data to guard against. can be a number or a string (WGSL `u32` expression).\n   */\n  guardAgainstOutOfBoundsWorkgroupSizes(size: unknown): string;\n\n  /**\n   * A helper function to generate the code snippet for declaring multiple inputs or outputs.\n   *\n   * @param variables - an array of IndicesHelper for the variables.\n   */\n  declareVariables(...variables: IndicesHelper[]): string;\n\n  /**\n   * A helper function to register one uniform. Can be called multiple times to register multiple uniforms.\n   *\n   * @param name - the name of the uniform.\n   * @param type - the type of the uniform.\n   * @param length - the length of the uniform, default to 1 when it is not provided.\n   */\n  registerUniform(name: string, type: string, length?: number): ShaderHelper;\n\n  /**\n   * A helper function to register multiple uniforms. Can be called multiple times to register multiple uniforms.\n   *\n   * @param uniforms - an array of uniforms. Each element of the array is an object with 2 properties: `name` and\n   *     `type`.\n   */\n  registerUniforms(uniforms: UniformsArrayType): ShaderHelper;\n\n  /**\n   * A helper function to register multiple internal variables. Can be called multiple times to register multiple\n   * internal variables.\n   *\n   * @param variables - an array of IndicesHelper for the variables.\n   */\n  registerInternalVariables(...variables: IndicesHelper[]): ShaderHelper;\n}\n\nclass ShaderHelperImpl implements ShaderHelper {\n  constructor(\n    private normalizedDispatchGroup: [number, number, number],\n    private limits: GPUSupportedLimits,\n  ) {}\n\n  guardAgainstOutOfBoundsWorkgroupSizes(size: number | string): string {\n    // Guard against out-of-bounds work group sizes\n    const sizeInCode = typeof size === 'number' ? `${size}u` : size;\n    return `if (global_idx >= ${sizeInCode}) { return; }`;\n  }\n\n  mainStart(workgroupSize: number | [number, number, number] = WORKGROUP_SIZE) {\n    const workgroupSizeX = typeof workgroupSize === 'number' ? workgroupSize : workgroupSize[0];\n    const workgroupSizeY = typeof workgroupSize === 'number' ? 1 : workgroupSize[1];\n    const workgroupSizeZ = typeof workgroupSize === 'number' ? 1 : workgroupSize[2];\n\n    if (\n      workgroupSizeX > this.limits.maxComputeWorkgroupSizeX ||\n      workgroupSizeY > this.limits.maxComputeWorkgroupSizeY ||\n      workgroupSizeZ > this.limits.maxComputeWorkgroupSizeZ\n    ) {\n      throw new Error(\n        `workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${\n          workgroupSizeZ\n        }] exceeds the maximum workgroup size [${this.limits.maxComputeWorkgroupSizeX}, ${\n          this.limits.maxComputeWorkgroupSizeY\n        }, ${this.limits.maxComputeWorkgroupSizeZ}].`,\n      );\n    }\n\n    if (workgroupSizeX * workgroupSizeY * workgroupSizeZ > this.limits.maxComputeInvocationsPerWorkgroup) {\n      throw new Error(\n        `workgroup size [${workgroupSizeX}, ${workgroupSizeY}, ${\n          workgroupSizeZ\n        }] exceeds the maximum workgroup invocations ${this.limits.maxComputeInvocationsPerWorkgroup}.`,\n      );\n    }\n\n    const is1DimensionDispatch = this.normalizedDispatchGroup[1] === 1 && this.normalizedDispatchGroup[2] === 1;\n    const paramList = is1DimensionDispatch\n      ? `@builtin(global_invocation_id) global_id : vec3<u32>,\n    @builtin(workgroup_id) workgroup_id : vec3<u32>,\n    @builtin(local_invocation_index) local_idx : u32,\n    @builtin(local_invocation_id) local_id : vec3<u32>`\n      : `@builtin(global_invocation_id) global_id : vec3<u32>,\n                                             @builtin(local_invocation_id) local_id : vec3<u32>,\n    @builtin(local_invocation_index) local_idx : u32,\n    @builtin(workgroup_id) workgroup_id : vec3<u32>,\n    @builtin(num_workgroups) num_workgroups : vec3<u32>`;\n    const globalIdxDefinition = is1DimensionDispatch\n      ? `let global_idx = global_id.x;\n         let workgroup_index = workgroup_id.x;`\n      : `let workgroup_index = workgroup_id.z * num_workgroups[0] * num_workgroups[1] +\n             workgroup_id.y * num_workgroups[0] + workgroup_id.x;\n         let global_idx = workgroup_index * ${workgroupSizeX * workgroupSizeY * workgroupSizeZ}u + local_idx;`;\n\n    return `@compute @workgroup_size(${workgroupSizeX}, ${workgroupSizeY}, ${workgroupSizeZ})\n  fn main(${paramList}) {\n    ${globalIdxDefinition}\n  `;\n  }\n\n  private appendVariableUniforms(variable: IndicesHelper): void {\n    if (variable.rank !== 0) {\n      if (variable.shape.startsWith('uniforms.')) {\n        this.uniforms.push({ name: variable.shape.replace('uniforms.', ''), type: 'u32', length: variable.rank });\n      }\n      if (variable.strides.startsWith('uniforms.')) {\n        this.uniforms.push({ name: variable.strides.replace('uniforms.', ''), type: 'u32', length: variable.rank });\n      }\n    }\n  }\n\n  private declareVariable(variable: IndicesHelper, bindingIndex: number): string {\n    if (variable.usage === 'internal') {\n      throw new Error('cannot use internal variable with declareVariable(). use registerInternalVariables() instead.');\n    }\n    this.variables.push(variable);\n    this.appendVariableUniforms(variable);\n    const access = variable.usage === 'input' ? 'read' : 'read_write';\n    const storageType = variable.usage === 'atomicOutput' ? `atomic<i32>` : variable.type.storage;\n    return `@group(0) @binding(${bindingIndex}) var<storage, ${access}> ${variable.name}: array<${storageType}>;`;\n  }\n\n  declareVariables(...variables: IndicesHelper[]): string {\n    return variables.map((v) => this.declareVariable(v, this.variableIndex++)).join('\\n');\n  }\n\n  private registerInternalVariable(variable: IndicesHelper): void {\n    if (variable.usage !== 'internal') {\n      throw new Error(\n        'cannot use input or output variable with registerInternalVariable(). use declareVariables() instead.',\n      );\n    }\n\n    this.internalVariables.push(variable);\n    this.appendVariableUniforms(variable);\n  }\n\n  registerInternalVariables(...variables: IndicesHelper[]): ShaderHelper {\n    variables.forEach((v) => this.registerInternalVariable(v));\n    return this;\n  }\n\n  registerUniform(name: string, type: UniformDataElementType, length = 1): ShaderHelper {\n    this.uniforms.push({ name, type, length });\n    return this;\n  }\n\n  registerUniforms(additionalUniforms: UniformsArrayType): ShaderHelper {\n    this.uniforms = this.uniforms.concat(additionalUniforms);\n    return this;\n  }\n\n  private internalVariables: IndicesHelper[] = [];\n  private variables: IndicesHelper[] = [];\n  private uniforms: UniformsArrayType = [];\n  private uniformDeclaration(): string {\n    if (this.uniforms.length === 0) {\n      return '';\n    }\n\n    const uniformSnippets: string[] = [];\n    for (const { name, type, length } of this.uniforms) {\n      if (length && length > 4) {\n        if (type === 'f16') {\n          uniformSnippets.push(`@align(16) ${name}:array<mat2x4<${type}>, ${Math.ceil(length / 8)}>`);\n        } else {\n          uniformSnippets.push(`${name}:array<vec4<${type}>, ${Math.ceil(length / 4)}>`);\n        }\n      } else {\n        const typeTemp = length == null || length === 1 ? type : `vec${length}<${type}>`;\n        uniformSnippets.push(`${name}:${typeTemp}`);\n      }\n    }\n\n    return `\n      struct Uniforms { ${uniformSnippets.join(', ')} };\n      @group(0) @binding(${this.variableIndex}) var<uniform> uniforms: Uniforms;`;\n  }\n  private variableIndex = 0;\n\n  /**\n   * Get additional implementation that needs to be added to the shader source.\n   */\n  get additionalImplementations(): string {\n    return (\n      this.uniformDeclaration() +\n      this.variables.map((i) => i.impl()).join('\\n') +\n      this.internalVariables.map((i) => i.impl()).join('\\n')\n    );\n  }\n\n  /**\n   * Get the variable info of the shader program.\n   */\n  get variablesInfo(): ProgramUniformVariableInfo[] | undefined {\n    if (this.uniforms.length === 0) {\n      return undefined;\n    }\n\n    const uniformWgslTypeToDataType = (type: UniformDataElementType) =>\n      [DataType.uint32, DataType.float16, DataType.float, DataType.int32][['u32', 'f16', 'f32', 'i32'].indexOf(type)];\n    return this.uniforms.map((u) => [uniformWgslTypeToDataType(u.type), u.length ?? 1]);\n  }\n}\n\nexport const createShaderHelper = (dispatchGroup: [number, number, number], limits: GPUSupportedLimits) =>\n  new ShaderHelperImpl(dispatchGroup, limits);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo } from '../types';\n\nimport { createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper } from './common';\n\nexport interface TransposeAttributes extends AttributeWithCacheKey {\n  readonly perm: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[], perm: readonly number[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Transpose requires 1 input.');\n  }\n\n  if (perm.length !== 0 && perm.length !== inputs[0].dims.length) {\n    throw new Error(`perm size ${perm.length} does not match input rank ${inputs[0].dims.length}`);\n  }\n};\n\nconst getAdjustedPerm = (inputRank: number, perm: number[]): number[] =>\n  perm.length !== 0 ? perm : [...new Array(inputRank).keys()].reverse();\n\nconst getOutputShape = (inputShape: readonly number[], perm: number[]): readonly number[] =>\n  ShapeUtil.sortBasedOnPerm(inputShape, getAdjustedPerm(inputShape.length, perm));\n\nconst permFunctionBody = (perm: number[], rank: number, input: IndicesHelper, output: IndicesHelper): string => {\n  let reverseFunc = `fn perm(i: ${output.type.indices}) -> ${input.type.indices} {\n    var a: ${input.type.indices};`;\n  for (let i = 0; i < rank; ++i) {\n    // input indices and output indices should always be larger or equal to 2,\n    // so indexer is always valid to be used on `a` and `i`.\n    reverseFunc += `a[${perm[i]}]=i[${i}];`;\n  }\n  return (reverseFunc += 'return a;}');\n};\n\nconst squeezeShape = (shape: readonly number[], adjustedPerm: number[]): { newShape: number[]; newPerm: number[] } => {\n  const newShape: number[] = [];\n  const newPerm: number[] = [];\n  for (let i = 0; i < shape.length; ++i) {\n    if (shape[i] !== 1) {\n      newShape.push(shape[i]);\n    }\n    if (shape[adjustedPerm[i]] !== 1) {\n      newPerm.push(adjustedPerm[i]);\n    }\n  }\n  return { newShape, newPerm };\n};\n\nconst isTransposeReshape = (perm: number[], shape: readonly number[]) => {\n  // As long as the dims with values > 1 stay in the same order, it's a reshape.\n  // Example: Shape=(1,1,1024,4096) -> perm=(2,0,3,1).\n  let lastPermutedAxis = 0;\n  for (let i = 0; i < perm.length; ++i) {\n    if (shape[perm[i]] === 1) {\n      continue;\n    }\n    if (perm[i] < lastPermutedAxis) {\n      return false;\n    }\n    lastPermutedAxis = perm[i];\n  }\n  return true;\n};\n\nexport const createTransposeProgramInfo = (inputTensor: TensorView, permAttr: number[]): ProgramInfo => {\n  const inputDataType = inputTensor.dataType;\n  const inputRank = inputTensor.dims.length;\n  const perm = getAdjustedPerm(inputRank, permAttr);\n  const outputShape = getOutputShape(inputTensor.dims, perm);\n  let newInputShape = inputTensor.dims;\n  let newOutputShape = outputShape;\n  const transposeAsReshape = inputRank < 2 || isTransposeReshape(perm, inputTensor.dims);\n  let getShaderSource;\n  if (transposeAsReshape) {\n    getShaderSource = (shaderHelper: ShaderHelper) => {\n      const input = inputVariable('input', inputDataType, newInputShape, 4);\n      const output = outputVariable('output', inputDataType, newOutputShape, 4);\n      return `\n  ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(input, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    output[global_idx] = input[global_idx];\n  }`;\n    };\n\n    return {\n      name: 'TransposeCopy',\n      shaderCache: { inputDependencies: ['type'] },\n      getRunData: () => {\n        const outputSize = ShapeUtil.size(outputShape);\n        return {\n          outputs: [{ dims: outputShape, dataType: inputTensor.dataType }],\n          dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */ / 4 /* components */) },\n          programUniforms: [{ type: DataType.uint32, data: Math.ceil(outputSize / 4) }],\n        };\n      },\n      getShaderSource,\n    };\n  }\n  const { newShape, newPerm } = squeezeShape(inputTensor.dims, perm);\n  const channelsLast = ShapeUtil.areEqual(newPerm, [2, 3, 1]);\n  const channelsFirst = ShapeUtil.areEqual(newPerm, [3, 1, 2]);\n  const useShared = newShape.length === 2 || channelsLast || channelsFirst;\n  if (useShared) {\n    newInputShape = channelsLast\n      ? [newShape[0], newShape[1] * newShape[2]]\n      : channelsFirst\n        ? [newShape[0] * newShape[1], newShape[2]]\n        : newShape;\n    newOutputShape = [newInputShape[1], newInputShape[0]];\n    const tileSize = 16;\n    getShaderSource = (shaderHelper: ShaderHelper) => {\n      const input = inputVariable('a', inputDataType, newInputShape.length);\n      const output = outputVariable('output', inputDataType, newOutputShape.length);\n      return `\n  ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(input, output)}\n  var<workgroup> tile : array<array<${output.type.value}, ${tileSize + 1}>, ${tileSize}>;\n  ${shaderHelper.mainStart([tileSize, tileSize, 1])}\n    let stride = (uniforms.output_shape[1] - 1) / ${tileSize} + 1;\n    let workgroup_id_x = workgroup_index % stride;\n    let workgroup_id_y = workgroup_index / stride;\n    let input_col = workgroup_id_y * ${tileSize}u + local_id.x;\n    let input_row = workgroup_id_x * ${tileSize}u + local_id.y;\n    if (input_row < uniforms.a_shape[0] && input_col < uniforms.a_shape[1]) {\n      tile[local_id.y][local_id.x] = ${input.getByIndices(`${input.type.indices}(input_row, input_col)`)};\n    }\n    workgroupBarrier();\n\n    let output_col = workgroup_id_x * ${tileSize}u + local_id.x;\n    let output_row = workgroup_id_y * ${tileSize}u + local_id.y;\n    if (output_row < uniforms.output_shape[0] && output_col < uniforms.output_shape[1]) {\n      ${output.setByIndices(`${output.type.indices}(output_row, output_col)`, 'tile[local_id.x][local_id.y]')}\n    }\n  }`;\n    };\n    return {\n      name: 'TransposeShared',\n      shaderCache: { inputDependencies: ['type'] },\n      getRunData: () => {\n        const outputSize = ShapeUtil.size(outputShape);\n        return {\n          outputs: [{ dims: outputShape, dataType: inputTensor.dataType }],\n          dispatchGroup: { x: Math.ceil(newOutputShape[1] / tileSize), y: Math.ceil(newOutputShape[0] / tileSize) },\n          programUniforms: [\n            { type: DataType.uint32, data: outputSize },\n            ...createTensorShapeVariables(newInputShape, newOutputShape),\n          ],\n        };\n      },\n      getShaderSource,\n    };\n  }\n\n  getShaderSource = (shaderHelper: ShaderHelper) => {\n    const input = inputVariable('a', inputDataType, newInputShape.length);\n    const output = outputVariable('output', inputDataType, newOutputShape.length);\n    return `\n  ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(input, output)}\n\n  ${permFunctionBody(perm, inputRank, input, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let indices = ${output.offsetToIndices('global_idx')};\n    let aIndices = perm(indices);\n\n    ${output.setByOffset('global_idx', input.getByIndices('aIndices'))}\n  }`;\n  };\n  return {\n    name: 'Transpose',\n    shaderCache: { hint: `${permAttr}`, inputDependencies: ['rank'] },\n    getRunData: () => {\n      const outputSize = ShapeUtil.size(outputShape);\n      return {\n        outputs: [{ dims: outputShape, dataType: inputTensor.dataType }],\n        dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n        programUniforms: [\n          { type: DataType.uint32, data: outputSize },\n          ...createTensorShapeVariables(newInputShape, newOutputShape),\n        ],\n      };\n    },\n    getShaderSource,\n  };\n};\n\nexport const transpose = (context: ComputeContext, attributes: TransposeAttributes): void => {\n  validateInputs(context.inputs, attributes.perm);\n  context.compute(createTransposeProgramInfo(context.inputs[0], attributes.perm));\n};\n\nexport const parseTransposeAttributes = (attributes: Record<string, unknown>): TransposeAttributes =>\n  createAttributeWithCacheKey({ perm: attributes.perm as number[] });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { ComputeContext, ProgramInfo } from '../types';\n\nimport { inputVariable, outputVariable, ShaderHelper } from './common';\nimport { createReduceAttributesFromInputs, ReduceAttributes } from './reduce';\nimport { createTransposeProgramInfo } from './transpose';\n\nconst reduceOps: { [key: string]: string } = {\n  max: 'select(bestValue, candidate, candidate > bestValue)',\n  min: 'select(bestValue, candidate, candidate < bestValue)',\n  mean: 'bestValue + candidate',\n  sum: 'bestValue + candidate',\n  prod: 'bestValue * candidate',\n  sumSquare: 'bestValue + candidate * candidate',\n  logSumExp: 'bestValue + exp(candidate)',\n  l1: 'bestValue + abs(candidate)',\n  l2: 'bestValue + candidate * candidate',\n  logSum: 'bestValue + candidate',\n};\n\nconst reduceSharedOps: { [key: string]: string } = {\n  max: 'select(bestValue, candidate, candidate > bestValue)',\n  min: 'select(bestValue, candidate, candidate < bestValue)',\n  mean: 'bestValue + candidate',\n  sum: 'bestValue + candidate',\n  prod: 'bestValue * candidate',\n  sumSquare: 'bestValue + candidate',\n  logSumExp: 'bestValue + candidate',\n  l1: 'bestValue + candidate',\n  l2: 'bestValue + candidate',\n  logSum: 'bestValue + candidate',\n};\n\nconst reduceInitValues: { [key: string]: string } = {\n  max: '_A[offset]',\n  min: '_A[offset]',\n  mean: '0',\n  sum: '0',\n  prod: '1',\n  sumSquare: '0',\n  logSumExp: '0',\n  l1: '0',\n  l2: '0',\n  logSum: '0',\n};\n\nconst reduceOutputValues: { [key: string]: string } = {\n  max: 'bestValue',\n  min: 'bestValue',\n  sum: 'bestValue',\n  prod: 'bestValue',\n  sumSquare: 'bestValue',\n  logSumExp: 'log(bestValue)',\n  l1: 'bestValue',\n  l2: 'sqrt(bestValue)',\n  logSum: 'log(bestValue)',\n};\n\nconst getInnerMostAxes = (numInnerAxes: number, rank: number): number[] => {\n  const res = [];\n  for (let i = rank - numInnerAxes; i < rank; ++i) {\n    res.push(i);\n  }\n  return res;\n};\n\nconst computeOutAndReduceShapes = (shape: readonly number[], axes: readonly number[]): [number[], number[]] => {\n  const outputShape = [];\n  const rank = shape.length;\n  for (let dim = 0; dim < rank; dim++) {\n    if (axes.indexOf(dim) === -1) {\n      outputShape.push(shape[dim]);\n    }\n  }\n  const reduceShape = axes.map((dim) => shape[dim]);\n  return [outputShape, reduceShape];\n};\n\nconst expandShapeToKeepDim = (shape: number[], axes: number[]): number[] => {\n  const rank = shape.length + axes.length;\n  const expandShape = [];\n  let shapeIdx = 0;\n  for (let dim = 0; dim < rank; dim++) {\n    if (axes.indexOf(dim) === -1) {\n      expandShape.push(shape[shapeIdx++]);\n    } else {\n      expandShape.push(1);\n    }\n  }\n  return expandShape;\n};\n\nconst areAxesInnerMostDims = (axes: number[], rank: number): boolean => {\n  for (let i = 0; i < axes.length; ++i) {\n    if (axes[axes.length - i - 1] !== rank - 1 - i) {\n      return false;\n    }\n  }\n  return true;\n};\n\nconst getAxesPermutation = (axes: number[], rank: number): number[] => {\n  const res = [];\n  if (!areAxesInnerMostDims(axes, rank)) {\n    for (let i = 0; i < rank; ++i) {\n      if (axes.indexOf(i) === -1) {\n        res.push(i);\n      }\n    }\n    axes.forEach((axis) => res.push(axis));\n  }\n  return res;\n};\n\nexport const createReduceSharedProgramInfo = (\n  name: string,\n  cacheKey: string,\n  inputs: readonly TensorView[],\n  reduceType: string,\n  outputDataType: DataType,\n  outputShape: number[],\n  reduceShape: number[],\n): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n\n  const outputSize = ShapeUtil.size(outputShape);\n  const reduceSize = ShapeUtil.size(reduceShape);\n\n  const input = inputVariable('_A', inputs[0].dataType, inputShape);\n  const output = outputVariable('output', outputDataType, outputShape);\n\n  let workgroupSize = 64;\n  // If only one workgroup is dispatched, increase workgroupSize to improve parallelism.\n  if (outputSize === 1) {\n    workgroupSize = 256;\n  }\n\n  const sharedMemorySnippet = `\n          var<workgroup> aBestValues : array<f32, ${workgroupSize}>;\n       `;\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n        ${shaderHelper.registerUniform('reduceSize', 'u32').declareVariables(input, output)}\n        ${sharedMemorySnippet}\n        fn DIV_CEIL(a : u32, b : u32) -> u32 {\n          return ((a - 1u) / b + 1u);\n         }\n         ${shaderHelper.mainStart(workgroupSize)}\n\n          let outputIndex = global_idx / ${workgroupSize};\n          let offset = outputIndex * uniforms.reduceSize;\n\n          var bestValue = f32(${reduceInitValues[reduceType]});\n          let Length = uniforms.reduceSize;\n          for (var k = local_idx; k < Length; k = k + ${workgroupSize}) {\n           let candidate = f32(${input.getByOffset('offset + k')});\n           bestValue = ${reduceOps[reduceType]};\n          }\n          aBestValues[local_idx] = bestValue;\n          workgroupBarrier();\n\n         var reduceSize = min(Length, ${workgroupSize}u);\n         for (var currentSize = reduceSize / 2u; reduceSize > 1u;\n             currentSize = reduceSize / 2u) {\n           let interval = DIV_CEIL(reduceSize, 2u);\n           if (local_idx < currentSize) {\n            let candidate = aBestValues[local_idx + interval];\n            bestValue = ${reduceSharedOps[reduceType]};\n            aBestValues[local_idx] = bestValue;\n           }\n           reduceSize = interval;\n           workgroupBarrier();\n         }\n\n         if (local_idx == 0u) {\n          ${output.setByOffset(\n            'outputIndex',\n            `${\n              reduceType === 'mean'\n                ? `${output.type.storage}(bestValue / f32(uniforms.reduceSize))`\n                : `${output.type.storage}(${reduceOutputValues[reduceType]})`\n            }`,\n          )};\n         }\n        }`;\n\n  // One work group is responsible for only one element of output.\n  return {\n    name,\n    // Note that in JSEP, WG size is not included in cache by default, but WebGPU EP it is.\n    shaderCache: { hint: `${cacheKey};${workgroupSize}`, inputDependencies: ['type'] },\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: outputDataType }],\n      dispatchGroup: { x: outputSize },\n      programUniforms: [{ type: DataType.uint32, data: reduceSize }],\n    }),\n  };\n};\n\nconst reduceCommon = (\n  context: ComputeContext,\n  name: string,\n  attributes: ReduceAttributes,\n  reduceType: 'sum' | 'sumSquare' | 'prod' | 'min' | 'max' | 'mean' | 'logSumExp' | 'l1' | 'l2' | 'logSum',\n): void => {\n  const updatedAttributes: ReduceAttributes =\n    context.inputs.length === 1 ? attributes : createReduceAttributesFromInputs(context.inputs, attributes);\n\n  let updatedAxes = updatedAttributes.axes;\n  if (updatedAxes.length === 0 && !updatedAttributes.noopWithEmptyAxes) {\n    updatedAxes = context.inputs[0].dims.map((_dim, i) => i);\n  }\n  const normalizeAxes = ShapeUtil.normalizeAxes(updatedAxes, context.inputs[0].dims.length);\n\n  let axes = normalizeAxes;\n  let input = context.inputs[0];\n  const permutedAxes = getAxesPermutation(axes, context.inputs[0].dims.length);\n  if (permutedAxes.length > 0) {\n    input = context.compute(createTransposeProgramInfo(context.inputs[0], permutedAxes), {\n      inputs: [0],\n      outputs: [-1],\n    })[0];\n    axes = getInnerMostAxes(axes.length, input.dims.length);\n  }\n\n  const [outputShape, reduceShape] = computeOutAndReduceShapes(input.dims, axes);\n  let finalOutputShape = outputShape;\n  if (updatedAttributes.keepDims) {\n    finalOutputShape = expandShapeToKeepDim(outputShape, normalizeAxes);\n  }\n\n  context.compute(\n    createReduceSharedProgramInfo(\n      name,\n      updatedAttributes.cacheKey,\n      [input],\n      reduceType,\n      context.inputs[0].dataType,\n      finalOutputShape,\n      reduceShape,\n    ),\n    { inputs: [input] },\n  );\n};\n\nexport const reduceMeanShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceMeanShared', attributes, 'mean');\n};\n\nexport const reduceL1Shared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceL1Shared', attributes, 'l1');\n};\n\nexport const reduceL2Shared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceL2Shared', attributes, 'l2');\n};\n\nexport const reduceLogSumExpShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceLogSumExpShared', attributes, 'logSumExp');\n};\n\nexport const reduceMaxShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceMaxShared', attributes, 'max');\n};\n\nexport const reduceMinShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceMinShared', attributes, 'min');\n};\n\nexport const reduceProdShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceProdShared', attributes, 'prod');\n};\n\nexport const reduceSumShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceSumShared', attributes, 'sum');\n};\n\nexport const reduceSumSquareShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceSumSquareShared', attributes, 'sumSquare');\n};\n\nexport const reduceLogSumShared = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  reduceCommon(context, 'ReduceLogSumShared', attributes, 'logSum');\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramShaderCacheInfo } from '../types';\n\nimport { createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper } from './common';\nimport {\n  reduceL1Shared,\n  reduceL2Shared,\n  reduceLogSumExpShared,\n  reduceLogSumShared,\n  reduceMaxShared,\n  reduceMeanShared,\n  reduceMinShared,\n  reduceProdShared,\n  reduceSumShared,\n  reduceSumSquareShared,\n} from './reduce-shared';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length === 0 || inputs.length > 2) {\n    throw new Error('Reduce op requires 1 or 2 inputs.');\n  }\n\n  if (inputs.length === 2 && inputs[1].dims.length !== 1) {\n    throw new Error('Invalid axes input dims.');\n  }\n};\n\nexport interface ReduceAttributes extends AttributeWithCacheKey {\n  keepDims: boolean;\n  noopWithEmptyAxes: boolean;\n  axes: number[];\n}\n\nexport type ReduceOp = (\n  input: IndicesHelper,\n  output: IndicesHelper,\n  axes: readonly number[],\n) => [string, string, string, string, ...string[]];\n\nconst noOp: ReduceOp = (input) => ['', '', `var value = ${input.getByIndices('input_indices')};`, ''];\nexport const createReduceProgramInfo = (\n  name: string,\n  shaderCache: ProgramShaderCacheInfo,\n  inputs: readonly TensorView[],\n  reduceOp: ReduceOp,\n  axesInput: number[],\n  outputDataType: DataType,\n  keepDims = false,\n  noopWithEmptyAxes = false,\n): ProgramInfo => {\n  const outputShape: number[] = [];\n  const inputShape = inputs[0].dims;\n  const inputRank = inputShape.length;\n  const axes = ShapeUtil.normalizeAxes(axesInput, inputRank);\n  const reduceOnAllAxes = !noopWithEmptyAxes && axes.length === 0;\n  inputShape.forEach((d, i) => {\n    if (reduceOnAllAxes || axes.indexOf(i) >= 0) {\n      if (keepDims) {\n        outputShape.push(1);\n      } // else { // skip this axis}\n    } else {\n      outputShape.push(d);\n    }\n  });\n  const outputRank = outputShape.length;\n  const outputSize = ShapeUtil.size(outputShape);\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const idxCopy: string[] = []; // copy output indexes to input indexes\n\n    const input = inputVariable('_A', inputs[0].dataType, inputRank);\n    const output = outputVariable('output', outputDataType, outputRank);\n    const ops = reduceOp(input, output, axes);\n    let reduceOps = ops[2];\n\n    for (let k = 0, l = 0; k < inputRank; k++) {\n      // if this axis is reduced\n      if (reduceOnAllAxes || axes.indexOf(k) >= 0) {\n        if (keepDims) {\n          l++;\n        }\n        // loop over the d-th axis\n        reduceOps = `for(var j${k}: u32 = 0; j${k} < ${inputShape[k]}; j${k}++) {\n                  ${ops[2].includes('last_index') ? `let last_index = j${k};` : ''}\n                  ${input.indicesSet('input_indices', k, `j${k}`)}\n                  ${reduceOps}\n                }`;\n      } else {\n        idxCopy.push(`${input.indicesSet('input_indices', k, output.indicesGet('output_indices', l))};`);\n        l++;\n      }\n    }\n    return `\n\n        ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(input, output)}\n\n        ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n          var input_indices: ${input.type.indices};\n          let output_indices = ${output.offsetToIndices('global_idx')};\n\n          ${idxCopy.join('\\n')}\n          ${ops[0]}       // init ops for reduce max/min\n          ${ops[1]}\n          ${reduceOps}\n          ${ops[3]}\n          ${ops.length === 4 ? output.setByOffset('global_idx', 'value') : ops.slice(4).join('\\n')}\n        }`;\n  };\n\n  return {\n    name,\n    shaderCache,\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: outputDataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms: [\n        { type: DataType.uint32, data: outputSize },\n        ...createTensorShapeVariables(inputShape, outputShape),\n      ],\n    }),\n  };\n};\n\nexport const createReduceAttributesFromInputs = (\n  inputs: readonly TensorView[],\n  attributes: ReduceAttributes,\n): ReduceAttributes => {\n  const axes: number[] = [];\n  if (inputs[1].dims[0] > 0) {\n    inputs[1].getBigInt64Array().forEach((v) => axes.push(Number(v)));\n  }\n  return createAttributeWithCacheKey({\n    axes,\n    keepDims: attributes.keepDims,\n    noopWithEmptyAxes: attributes.noopWithEmptyAxes,\n  });\n};\n\nconst runReduceProgram = (\n  context: ComputeContext,\n  name: string,\n  attributes: ReduceAttributes,\n  reduceOp: ReduceOp,\n): void => {\n  const inputs = context.inputs;\n  const updatedAttributes: ReduceAttributes =\n    inputs.length === 1 ? attributes : createReduceAttributesFromInputs(inputs, attributes);\n\n  context.compute(\n    createReduceProgramInfo(\n      name,\n      { hint: updatedAttributes.cacheKey, inputDependencies: ['rank'] },\n      [inputs[0]],\n      updatedAttributes.noopWithEmptyAxes && updatedAttributes.axes.length === 0 ? noOp : reduceOp,\n      updatedAttributes.axes,\n      inputs[0].dataType,\n      updatedAttributes.keepDims,\n      updatedAttributes.noopWithEmptyAxes,\n    ),\n    { inputs: [0] },\n  );\n};\n\nconst reduceLogSumNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) => [\n    `var value = ${output.type.storage}(0);`,\n    '',\n    `value += ${input.getByIndices('input_indices')};`,\n    'value = log(value);',\n  ];\n  runReduceProgram(context, 'ReduceLogSum', attributes, reduceOp);\n};\n\nconst reduceL1Naive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) => [\n    `var value = ${output.type.storage}(0);`,\n    '',\n    `value += abs(${input.getByIndices('input_indices')});`,\n    '',\n  ];\n  runReduceProgram(context, 'ReduceL1', attributes, reduceOp);\n};\n\nconst reduceL2Naive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) => [\n    `var t = ${output.type.value}(0); var value = ${output.type.value}(0);`,\n    '',\n    `t = ${input.getByIndices('input_indices')}; value += (t * t);`,\n    'value = sqrt(value);',\n  ];\n  runReduceProgram(context, 'ReduceL2', attributes, reduceOp);\n};\n\nconst reduceLogSumExpNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) => [\n    `var value = ${output.type.storage}(0);`,\n    '',\n    `value += exp(${input.getByIndices('input_indices')});`,\n    'value = log(value);',\n  ];\n  runReduceProgram(context, 'ReduceLogSumExp', attributes, reduceOp);\n};\n\nconst reduceMaxNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, _output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(input.indicesSet('input_indices', k, 0));\n      }\n    }\n\n    return [\n      `${idxZero.join('\\n')}`,\n      `var value = ${input.getByIndices('input_indices')};`,\n      `value = max(value, ${input.getByIndices('input_indices')});`,\n      '',\n    ];\n  };\n  runReduceProgram(context, 'ReduceMax', attributes, reduceOp);\n};\n\nconst reduceMeanNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output, axes) => {\n    let size = 1.0;\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        // TODO: this depends on the input dims. If we want to use uniform, this need to be updated.\n        size *= context.inputs[0].dims[k];\n      }\n    }\n\n    return [\n      'var sum = f32(0);',\n      '',\n      `sum += f32(${input.getByIndices('input_indices')});`,\n      `let value = ${output.type.value}(sum / ${size});`,\n    ];\n  };\n  runReduceProgram(context, 'ReduceMean', attributes, reduceOp);\n};\n\nconst reduceMinNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, _output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(`input_indices[${k}] = 0;`); // first element\n      }\n    }\n\n    return [\n      `${idxZero.join('\\n')}`,\n      `var value = ${input.getByIndices('input_indices')};`,\n      `value = min(value, ${input.getByIndices('input_indices')});`,\n      '',\n    ];\n  };\n  runReduceProgram(context, 'ReduceMin', attributes, reduceOp);\n};\n\nconst reduceProdNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) => [\n    `var value = ${output.type.storage}(1);`,\n    '',\n    `value *= ${input.getByIndices('input_indices')};`,\n    '',\n  ];\n  runReduceProgram(context, 'ReduceProd', attributes, reduceOp);\n};\n\nconst reduceSumNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) => [\n    `var value = ${output.type.storage}(0);`,\n    '',\n    `value += ${input.getByIndices('input_indices')};`,\n    '',\n  ];\n  runReduceProgram(context, 'ReduceSum', attributes, reduceOp);\n};\n\nconst reduceSumSquareNaive = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  validateInputs(context.inputs);\n  const reduceOp: ReduceOp = (input, output) => [\n    `var t = ${output.type.value}(0); var value = ${output.type.value}(0);`,\n    '',\n    `t = ${input.getByIndices('input_indices')}; value += t * t;`,\n    '',\n  ];\n  runReduceProgram(context, 'ReduceSumSquare', attributes, reduceOp);\n};\n\nconst useNaiveReduceMethod = (\n  shape: readonly number[],\n  axes: readonly number[],\n  noopWithEmptyAxes: boolean,\n): boolean => {\n  if (axes.length === 0) {\n    return noopWithEmptyAxes;\n  }\n\n  let outputSize = 1;\n  let reduceSize = 1;\n  for (let dim = 0; dim < axes.length; dim++) {\n    if (axes.indexOf(dim) === -1) {\n      outputSize *= shape[dim];\n    } else {\n      reduceSize *= shape[dim];\n    }\n  }\n\n  // The condition data is very rough, although considering the count of Execution Unit (EU), the potential\n  // work groups in a EU and the counts of loops in the naive and shared methods, also doing experiments\n  // on some machines.\n  return reduceSize < 32 && outputSize > 1024;\n};\n\nexport const reduceMean = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceMeanNaive(context, attributes);\n  } else {\n    reduceMeanShared(context, attributes);\n  }\n};\n\nexport const reduceL1 = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceL1Naive(context, attributes);\n  } else {\n    reduceL1Shared(context, attributes);\n  }\n};\n\nexport const reduceL2 = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceL2Naive(context, attributes);\n  } else {\n    reduceL2Shared(context, attributes);\n  }\n};\n\nexport const reduceLogSumExp = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceLogSumExpNaive(context, attributes);\n  } else {\n    reduceLogSumExpShared(context, attributes);\n  }\n};\n\nexport const reduceMax = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceMaxNaive(context, attributes);\n  } else {\n    reduceMaxShared(context, attributes);\n  }\n};\n\nexport const reduceMin = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceMinNaive(context, attributes);\n  } else {\n    reduceMinShared(context, attributes);\n  }\n};\n\nexport const reduceProd = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceProdNaive(context, attributes);\n  } else {\n    reduceProdShared(context, attributes);\n  }\n};\n\nexport const reduceSum = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceSumNaive(context, attributes);\n  } else {\n    reduceSumShared(context, attributes);\n  }\n};\n\nexport const reduceSumSquare = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceSumSquareNaive(context, attributes);\n  } else {\n    reduceSumSquareShared(context, attributes);\n  }\n};\n\nexport const reduceLogSum = (context: ComputeContext, attributes: ReduceAttributes): void => {\n  if (useNaiveReduceMethod(context.inputs[0].dims, attributes.axes, attributes.noopWithEmptyAxes)) {\n    reduceLogSumNaive(context, attributes);\n  } else {\n    reduceLogSumShared(context, attributes);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// TODO: this is the same naive implementation we use for reduce that has\n// performance limitations when the reduced axis is long. Need to add\n// a optimized codepath for this.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext } from '../types';\n\nimport { createReduceProgramInfo, ReduceOp } from './reduce';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length === 0 || inputs.length > 2) {\n    throw new Error('ArgMinMaxOp op requires 1 or 2 inputs.');\n  }\n  if (inputs[0].dataType !== DataType.float) {\n    throw new Error('Invalid input type.');\n  }\n};\n\nexport interface ArgMinMaxAttributes extends AttributeWithCacheKey {\n  keepDims: boolean;\n  axis: number;\n  selectLastIndex: number;\n}\n\nexport const argMin = (context: ComputeContext, attributes: ArgMinMaxAttributes): void => {\n  validateInputs(context.inputs);\n  const argMinMaxOp: ReduceOp = (input, output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(`input_indices[${k}] = 0;`); // first element\n      }\n    }\n    return [\n      `${idxZero.join('\\n')}`,\n      `var value = ${input.getByIndices('input_indices')};\\nvar best_index : i32 = 0;`,\n      `if (${input.getByIndices('input_indices')} ${attributes.selectLastIndex > 0 ? '<=' : '<'} value) {\n         value = ${input.getByIndices('input_indices')};\n         best_index = i32(last_index);\n       }`,\n      '',\n      output.setByOffset('global_idx', 'best_index'),\n    ];\n  };\n\n  context.compute(\n    createReduceProgramInfo(\n      'ArgMin',\n      { hint: attributes.cacheKey, inputDependencies: ['rank'] },\n      [context.inputs[0]],\n      argMinMaxOp,\n      [attributes.axis],\n      DataType.int64,\n      attributes.keepDims,\n    ),\n    { inputs: [0] },\n  );\n};\n\nexport const argMax = (context: ComputeContext, attributes: ArgMinMaxAttributes): void => {\n  validateInputs(context.inputs);\n  const argMinMaxOp: ReduceOp = (input, output, axes) => {\n    const idxZero = [];\n    for (let k = 0; k < input.rank; k++) {\n      if (axes.indexOf(k) >= 0 || axes.length === 0) {\n        idxZero.push(`input_indices[${k}] = 0;`); // first element\n      }\n    }\n    return [\n      `${idxZero.join('\\n')}`,\n      `var value = ${input.getByIndices('input_indices')};\\nvar best_index : i32 = 0;`,\n      `if (${input.getByIndices('input_indices')} ${attributes.selectLastIndex > 0 ? '>=' : '>'} value) {\n         value = ${input.getByIndices('input_indices')};\n         best_index = i32(last_index);\n       }`,\n      '',\n      output.setByOffset('global_idx', 'best_index'),\n    ];\n  };\n\n  context.compute(\n    createReduceProgramInfo(\n      'argMax',\n      { hint: attributes.cacheKey, inputDependencies: ['rank'] },\n      [context.inputs[0]],\n      argMinMaxOp,\n      [attributes.axis],\n      DataType.int64,\n      attributes.keepDims,\n    ),\n    { inputs: [0] },\n  );\n};\n\nexport const parseArgMinMaxAttributes = (attributes: Record<string, unknown>): ArgMinMaxAttributes =>\n  createAttributeWithCacheKey(attributes as Omit<ArgMinMaxAttributes, keyof AttributeWithCacheKey>);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { ComputeContext, GpuDataType, ProgramInputTensorInfoDependency, ProgramUniform } from '../types';\n\nimport {\n  getMaxComponents,\n  IndicesHelper,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  tensorTypeToWsglStorageType,\n  tensorTypeToWsglValueType,\n  UniformDataElementType,\n  UniformsArrayType,\n} from './common';\n\nexport const enum AttentionQkvFormat {\n  unknown, // enum value not set, or depends on qkv projection implementation details\n  qkvBNSH, // for non-packed qkv, permuted\n  qkvBSNH, // for non-packed qkv, not permuted, used by memory efficient attention or MultiHeadAttention\n  qkvBSN3H, // for TRT fused attention, qkv are packed\n  qkvBNSHqkvBS3NH, // for TRT fused causal attention, data has two formats (qkv is 3BNSH, gemm_buffer is BS3NH)\n  qKvBSNHxBSN2H, // for TRT fused cross attention, kv are packed\n  qkvTNH, // for memory efficient attention, qkv are not packed, and paddings are removed.\n  qkvTN3H, // for TRT fused attention, qkv are packed and paddings are removed\n}\n\nexport const enum AttentionMaskType {\n  none, // No mask\n  mask1dKeySeqLen, // [batch_size], key sequence length\n  mask1dEndStart, // [2 * batch_size] with end positions and start positions\n  mask1DKeySeqLenStart, // [3 * batch_size + 2] with [key_len[0], ..., key_len[batch_size - 1], query_start[0],\n  // ..., query_start[batch_size - 1], query_end[batch_size - 1], key_start[0], ...,\n  // key_start[batch_size - 1], key_end[batch_size - 1]]\n  mask2dDummy, // dummy mask with shape [1, 1] or [batch_size, 1]. It has same effect as no mask.\n  mask2dKeyPadding, // [batch_size, total_sequence_length]\n  mask3dAttention, // [batch_size, sequence_length, total_sequence_length]\n  mask4dMegatron, // Megatron causal mask with shape [batch_size, 1, max_sequence_length, max_sequence_length]\n  maskUnknown,\n}\n\nexport interface AttentionParameters {\n  batchSize: number;\n  sequenceLength: number;\n  pastSequenceLength: number;\n  kvSequenceLength: number;\n  totalSequenceLength: number;\n  maxSequenceLength: number;\n  inputHiddenSize: number;\n  hiddenSize: number;\n  vHiddenSize: number;\n  headSize: number;\n  vHeadSize: number;\n  numHeads: number;\n  kvNumHeads?: number;\n  nReps?: number;\n  isUnidirectional?: boolean;\n  pastPresentShareBuffer: boolean;\n  maskFilterValue?: number;\n  maskType: AttentionMaskType;\n  scale: number;\n  broadcastResPosBias: boolean;\n  passPastInKv: boolean;\n  qkvFormat: AttentionQkvFormat;\n  softcap?: number;\n  doRotary?: number;\n  rotaryInterLeaved?: number;\n  sommoothSoftmax?: number;\n  localWindowsSize?: number;\n}\n\nexport interface AttentionAttrs {\n  numHeads: number;\n  isUnidirectional: number;\n  maskFilterValue: number;\n  scale: number;\n  doRotary: number;\n  qkvHiddenSizes: number[];\n  pastPresentShareBuffer: boolean;\n}\n\nconst validateAttentionInputs = (inputs: readonly TensorView[], attributes: AttentionAttrs): AttentionParameters => {\n  // Abbreviation and Meanings:\n  //   B:    batch_size\n  //   S:    sequence_length (input sequence length of query)\n  //   P:    past_sequence_length (past sequence length of key or value)\n  //   L:    kv_sequence_length (input sequence length of key or value)\n  //   M:    max_sequence_length\n  //   T:    total_sequence_length = past_sequence_length + kv_sequence_length\n  //   N:    num_heads\n  //   H:    head size for Q and K, aka q_head_size or k_head_size or qk_head_size\n  //   H_v:  v_head_size\n  //   D_i:  input hidden size\n  //   D:    hidden size for Q and K (D = N * H), aka q_hidden_size or k_hidden_size or qk_hidden_size\n  //   D_v:  v_hidden_size = num_heads * v_head_size\n\n  // When past state is used, Q, K and V should have same hidden size (unless we split it into past_key and past_value).\n\n  // Input shapes:\n  //   input        (Q/K/V)    : (B, S, D_i)\n  //   weights      (Q/K/V)    : (D_i, D + D + D_v)\n  //   bias         (Q/K/V)    : (D + D + D_v)\n  //   mask_index              : see below\n  //   past         (K/V)      : (2, B, N, P, H) or NULL\n  //   attention_bias          : (B, N, S, T) or NULL\n\n  // For mask_index, the following shapes are supported:\n  //     NULL, (B, 1), (1, 1)\n  //     (B), (2 * B), (3 * B + 2)\n  //     (B, T)\n  //     (B, S, T)\n  //     (B, 1, M, M)\n  //\n  // When a model is pruned (like some attention heads are removed in Q/K/V), input_hidden_size could be larger\n  // than hidden dimension of Q, K and V.\n\n  const input = inputs[0];\n  const weights = inputs[1];\n  const bias = inputs[2];\n  const maskIndex = inputs[3];\n  const past = inputs[4];\n  const attentionBias = inputs[5];\n\n  if (past && attentionBias) {\n    throw new Error('Attention cannot have both past and attention_bias');\n  }\n\n  if (input.dims.length !== 3) {\n    throw new Error('Input \"input\" must have 3 dimensions');\n  }\n\n  const batchSize = input.dims[0];\n  const sequenceLength = input.dims[1];\n  const inputHiddenSize = input.dims[2];\n\n  if (bias.dims.length !== 1) {\n    throw new Error('Input \"bias\" is expected to have 1 dimensions');\n  }\n\n  if (weights.dims.length !== 2) {\n    throw new Error('Input \"weights\" is expected to have 2 dimensions');\n  }\n\n  if (weights.dims[0] !== inputHiddenSize) {\n    throw new Error('Input 1 dimension 0 should have same length as dimension 2 of input 0');\n  }\n\n  if (bias.dims[0] !== weights.dims[1]) {\n    throw new Error('Input \"bias\" dimension 0 should have same length as dimension 1 of input \"weights\"');\n  }\n\n  let qHiddenSize = bias.dims[0] / 3;\n  let kHiddenSize = qHiddenSize;\n  let vHiddenSize = kHiddenSize;\n  if (attributes.qkvHiddenSizes.length > 0) {\n    if (attributes.qkvHiddenSizes.length !== 3) {\n      throw new Error('qkv_hidden_sizes attribute should have 3 elements');\n    }\n    for (const sz of attributes.qkvHiddenSizes) {\n      if (sz % attributes.numHeads !== 0) {\n        throw new Error('qkv_hidden_sizes should be divisible by num_heads');\n      }\n    }\n\n    qHiddenSize = attributes.qkvHiddenSizes[0];\n    kHiddenSize = attributes.qkvHiddenSizes[1];\n    vHiddenSize = attributes.qkvHiddenSizes[2];\n  }\n\n  const kvSequenceLength = sequenceLength;\n\n  if (qHiddenSize !== kHiddenSize) {\n    throw new Error('qkv_hidden_sizes first element should be same as the second');\n  }\n\n  if (bias.dims[0] !== qHiddenSize + kHiddenSize + vHiddenSize) {\n    throw new Error('Input \"bias\" dimension 0 should have same length as sum of Q/K/V hidden sizes');\n  }\n\n  let pastSequenceLength = 0;\n  if (past) {\n    if (kHiddenSize !== vHiddenSize) {\n      throw new Error('Input \"past\" expect k_hidden_size == v_hidden_size');\n    }\n    if (past.dims.length !== 5) {\n      throw new Error('Input \"past\" must have 5 dimensions');\n    }\n    if (past.dims[0] !== 2) {\n      throw new Error('Input \"past\" first dimension must be 2');\n    }\n    if (past.dims[1] !== batchSize) {\n      throw new Error('Input \"past\" second dimension must be batch_size');\n    }\n    if (past.dims[2] !== attributes.numHeads) {\n      throw new Error('Input \"past\" third dimension must be num_heads');\n    }\n    if (past.dims[4] !== kHiddenSize / attributes.numHeads) {\n      throw new Error('Input \"past\" fifth dimension must be k_hidden_size / num_heads');\n    }\n\n    if (!attributes.pastPresentShareBuffer) {\n      pastSequenceLength = past.dims[3];\n    }\n    // TODO: handle past_seq_len\n  }\n\n  const totalSequenceLength = kvSequenceLength + pastSequenceLength;\n  const maxSequenceLength = -1;\n\n  const maskType = AttentionMaskType.none;\n  if (maskIndex) {\n    // maskType = AttentionMaskType.MASK_UNKNOWN;\n    // TODO: handle mask\n    throw new Error('Mask not supported');\n  }\n\n  if (past) {\n    throw new Error('past is not supported');\n  }\n\n  if (attentionBias) {\n    if (attentionBias.dims.length !== 4) {\n      throw new Error('Input \"attention_bias\" must have 4 dimensions');\n    }\n\n    // TODO: support broadcasting the first and second dimensions of attention_bias\n    if (\n      attentionBias.dims[0] !== batchSize ||\n      attentionBias.dims[1] !== attributes.numHeads ||\n      attentionBias.dims[2] !== sequenceLength ||\n      attentionBias.dims[3] !== totalSequenceLength\n    ) {\n      throw new Error('Expect \"attention_bias\" shape (batch_size, num_heads, sequence_length, total_sequence_length)');\n    }\n  }\n\n  return {\n    batchSize,\n    sequenceLength,\n    pastSequenceLength,\n    kvSequenceLength,\n    totalSequenceLength,\n    maxSequenceLength,\n    inputHiddenSize,\n    hiddenSize: qHiddenSize,\n    vHiddenSize,\n    headSize: Math.floor(qHiddenSize / attributes.numHeads),\n    vHeadSize: Math.floor(vHiddenSize / attributes.numHeads),\n    numHeads: attributes.numHeads,\n    isUnidirectional: false,\n    pastPresentShareBuffer: false,\n    maskFilterValue: attributes.maskFilterValue,\n    maskType,\n    scale: attributes.scale,\n    broadcastResPosBias: false,\n    passPastInKv: false,\n    qkvFormat: AttentionQkvFormat.qkvBNSH,\n  };\n};\n\nconst initVarStub = (\n  seqLensInput: IndicesHelper | undefined,\n  totalSequenceLengthInput: IndicesHelper | undefined,\n  initPastSequenceLength: boolean,\n) => {\n  // In the case of GQA, redefine total_sequence_length, present_sequence_length and past_sequence_length based on seqlen_k input\n  if (totalSequenceLengthInput && seqLensInput) {\n    return `\n      let total_sequence_length_input = u32(${totalSequenceLengthInput.getByOffset('0')});\n      let present_sequence_length = max(total_sequence_length_input, uniforms.past_sequence_length);\n      let is_subsequent_prompt: bool = sequence_length > 1 && sequence_length != total_sequence_length_input;\n      let is_first_prompt: bool = is_subsequent_prompt == false && sequence_length == total_sequence_length_input;\n      total_sequence_length = u32(${seqLensInput?.getByOffset('batchIdx')}) + 1;\n      var past_sequence_length: u32 = 0;\n      if (is_first_prompt == false) {\n        past_sequence_length = total_sequence_length - sequence_length;\n      }\n       `;\n  } else {\n    return `\n    ${initPastSequenceLength ? 'let past_sequence_length = uniforms.past_sequence_length' : ''};\n    let present_sequence_length = total_sequence_length;\n    `;\n  }\n};\n\nconst createInPlaceSoftmaxProgramInfo = (\n  input: TensorView,\n  batchSize: number,\n  numHeads: number,\n  pastSequenceLength: number,\n  sequenceLength: number,\n  totalSequenceLength: number,\n  seqLens: TensorView | undefined,\n  totalSequenceLengthInput: TensorView | undefined,\n) => {\n  // Set components to 1 if seqLens is specified, i.e. GroupQueryAttention.\n  const components = getMaxComponents(seqLens ? 1 : totalSequenceLength);\n  let WG = 64;\n  const totalSequenceLengthComp = totalSequenceLength / components;\n  if (totalSequenceLengthComp < WG) {\n    WG = 32;\n  }\n  const elementsPerThread = Math.ceil(totalSequenceLength / components / WG);\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: batchSize },\n    { type: DataType.uint32, data: numHeads },\n    { type: DataType.uint32, data: pastSequenceLength },\n    { type: DataType.uint32, data: sequenceLength },\n    { type: DataType.uint32, data: totalSequenceLengthComp },\n    { type: DataType.uint32, data: elementsPerThread },\n  ];\n  const dataType = tensorTypeToWsglStorageType(input.dataType, components);\n  const f32Type = tensorTypeToWsglValueType(DataType.float, components);\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['type'];\n  if (seqLens) {\n    inputDependencies.push('type');\n  }\n  if (totalSequenceLengthInput) {\n    inputDependencies.push('type');\n  }\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const inputHelper = outputVariable('x', input.dataType, input.dims, components);\n    const inputHelpers = [inputHelper];\n    const seqLensInputHelper = seqLens ? inputVariable('seq_lens', seqLens.dataType, seqLens.dims) : undefined;\n    if (seqLensInputHelper) {\n      inputHelpers.push(seqLensInputHelper);\n    }\n\n    const totalSequenceLengthInputHelper = totalSequenceLengthInput\n      ? inputVariable('total_sequence_length_input', totalSequenceLengthInput.dataType, totalSequenceLengthInput.dims)\n      : undefined;\n    if (totalSequenceLengthInputHelper) {\n      inputHelpers.push(totalSequenceLengthInputHelper);\n    }\n    const elemValueType = tensorTypeToWsglValueType(input.dataType);\n    const uniforms: UniformsArrayType = [\n      { name: 'batch_size', type: 'u32' },\n      { name: 'num_heads', type: 'u32' },\n      { name: 'past_sequence_length', type: 'u32' },\n      { name: 'sequence_length', type: 'u32' },\n      { name: 'total_sequence_length', type: 'u32' },\n      { name: 'elements_per_thread', type: 'u32' },\n    ];\n\n    return `\n  var<workgroup> thread_max: array<f32, ${WG}>;\n  var<workgroup> thread_sum: array<f32, ${WG}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputHelpers)}\n  ${shaderHelper.mainStart([WG, 1, 1])}\n    let batchIdx = workgroup_id.z / uniforms.num_heads;\n    let headIdx = workgroup_id.z % uniforms.num_heads;\n    let sequence_length = uniforms.sequence_length;\n    var total_sequence_length = uniforms.total_sequence_length;\n    ${initVarStub(seqLensInputHelper, totalSequenceLengthInputHelper, false)}\n    let local_offset = local_idx * uniforms.elements_per_thread;\n    let offset = (global_idx / ${WG}) * uniforms.total_sequence_length + local_offset;\n    let seq_causal_length = ${seqLens ? 'u32(past_sequence_length + workgroup_id.y + 1)' : 'total_sequence_length'};\n    var thread_max_vector = ${f32Type}(-3.4028234663852886e+38f);\n    for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < seq_causal_length; i++) {\n      thread_max_vector = max(${f32Type}(x[offset + i]), thread_max_vector);\n    }\n    thread_max[local_idx] = ${(() => {\n      switch (components) {\n        case 1:\n          return 'thread_max_vector';\n        case 2:\n          return 'max(thread_max_vector.x, thread_max_vector.y)';\n        case 4:\n          return 'max(max(thread_max_vector.x, thread_max_vector.y), max(thread_max_vector.z, thread_max_vector.w))';\n        default:\n          throw new Error(`Unsupported components: ${components}`);\n      }\n    })()};\n    workgroupBarrier();\n\n    var max_value =  f32(-3.4028234663852886e+38f);\n    for (var i = 0u; i < ${WG}; i++) {\n      max_value = max(thread_max[i], max_value);\n    }\n\n    var sum_vector = ${f32Type}(0);\n    for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < seq_causal_length; i++) {\n      sum_vector += exp(${f32Type}(x[offset + i]) - max_value);\n    }\n    thread_sum[local_idx] = ${(() => {\n      switch (components) {\n        case 1:\n          return 'sum_vector';\n        case 2:\n          return 'sum_vector.x + sum_vector.y';\n        case 4:\n          return 'sum_vector.x + sum_vector.y + sum_vector.z + sum_vector.w';\n        default:\n          throw new Error(`Unsupported components: ${components}`);\n      }\n    })()};\n    workgroupBarrier();\n\n    var sum: f32 = 0;\n    for (var i = 0u; i < ${WG}; i++) {\n      sum += thread_sum[i];\n    }\n\n    if (sum == 0) {\n      for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < seq_causal_length; i++) {\n        x[offset + i] = ${inputHelper.type.value}(${elemValueType}(1.0) / ${elemValueType}(seq_causal_length));\n      }\n    } else {\n      for (var i: u32 = 0; i < uniforms.elements_per_thread && i + local_offset < seq_causal_length; i++) {\n        var f32input = ${f32Type}(x[offset + i]);\n        x[offset + i] = ${inputHelper.type.value}(exp(f32input - max_value) / sum);\n      }\n    }\n      ${\n        seqLens\n          ? `\n        for (var total_seq_id: u32 = seq_causal_length; total_seq_id + local_offset < uniforms.total_sequence_length; total_seq_id++) {\n          x[offset + total_seq_id] = ${inputHelper.type.value}(${elemValueType}(0));\n        }`\n          : ''\n      };\n  }`;\n  };\n\n  return {\n    name: 'AttentionProbsSoftmax',\n    shaderCache: { hint: `${WG};${dataType};${components}`, inputDependencies },\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [],\n      dispatchGroup: { x: 1, y: sequenceLength, z: batchSize * numHeads },\n      programUniforms,\n    }),\n  };\n};\n\nconst createAttentionProbsProgramInfo = (\n  outputCount: number,\n  q: TensorView,\n  key: TensorView,\n  pastKey: TensorView | undefined,\n  attentionBias: TensorView | undefined,\n  parameters: AttentionParameters,\n  pastSequenceLength: number,\n  seqLens: TensorView | undefined,\n  totalSequenceLengthInput: TensorView | undefined,\n) => {\n  const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength;\n  const probsShape = [parameters.batchSize, parameters.numHeads, parameters.sequenceLength, totalSequenceLength];\n  const presentKey = outputCount > 1 && pastKey;\n  const kvNumHeads = parameters.kvNumHeads ? parameters.kvNumHeads : parameters.numHeads;\n  const presentKeyShape = presentKey\n    ? [parameters.batchSize, kvNumHeads, totalSequenceLength, parameters.headSize]\n    : undefined;\n  const nReps = parameters.nReps ? parameters.nReps : 1;\n  // TODO: handle mask\n\n  const alpha = parameters.scale === 0 ? 1.0 / Math.sqrt(parameters.headSize) : parameters.scale;\n  const components = getMaxComponents(parameters.headSize);\n  const vectorizedHeadSize = parameters.headSize / components;\n  const TILE_SIZE = 12;\n  const dispatch = {\n    x: Math.ceil(totalSequenceLength / TILE_SIZE),\n    y: Math.ceil(parameters.sequenceLength / TILE_SIZE),\n    z: parameters.batchSize * parameters.numHeads,\n  };\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: parameters.sequenceLength },\n    { type: DataType.uint32, data: vectorizedHeadSize },\n    { type: DataType.uint32, data: totalSequenceLength },\n    { type: DataType.uint32, data: parameters.numHeads },\n    { type: DataType.uint32, data: parameters.headSize },\n    { type: DataType.float, data: alpha },\n    { type: DataType.uint32, data: pastSequenceLength },\n    { type: DataType.uint32, data: parameters.kvSequenceLength },\n    { type: DataType.uint32, data: nReps },\n  ];\n  // Feed pastKey to the shader-code only if it is non-zero and presentKey is being produced\n  const feedPastKey = presentKey && pastKey && ShapeUtil.size(pastKey.dims) > 0;\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n  if (feedPastKey) {\n    inputDependencies.push('type');\n  }\n  if (attentionBias) {\n    inputDependencies.push('type');\n  }\n  if (seqLens) {\n    inputDependencies.push('type');\n  }\n  if (totalSequenceLengthInput) {\n    inputDependencies.push('type');\n  }\n  const outputs = [{ dims: probsShape, dataType: q.dataType, gpuDataType: GpuDataType.default }];\n  if (presentKey) {\n    outputs.push({ dims: presentKeyShape!, dataType: q.dataType, gpuDataType: GpuDataType.default });\n  }\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const qInput = inputVariable('q', q.dataType, q.dims, components);\n    const kInput = inputVariable('key', key.dataType, key.dims, components);\n    const inputVars = [qInput, kInput];\n    if (feedPastKey) {\n      const pastKeyInput = inputVariable('past_key', pastKey.dataType, pastKey.dims, components);\n      inputVars.push(pastKeyInput);\n    }\n    if (attentionBias) {\n      inputVars.push(inputVariable('attention_bias', attentionBias.dataType, attentionBias.dims));\n    }\n    const seqLensInputVariable = seqLens ? inputVariable('seq_lens', seqLens.dataType, seqLens.dims) : undefined;\n    if (seqLensInputVariable) {\n      inputVars.push(seqLensInputVariable);\n    }\n    const totalSequenceLengthInputVariable = totalSequenceLengthInput\n      ? inputVariable('total_sequence_length_input', totalSequenceLengthInput.dataType, totalSequenceLengthInput.dims)\n      : undefined;\n    if (totalSequenceLengthInputVariable) {\n      inputVars.push(totalSequenceLengthInputVariable);\n    }\n    const output = outputVariable('output', q.dataType, probsShape);\n    const outputVars = [output];\n    if (presentKey) {\n      outputVars.push(outputVariable('present_key', q.dataType, presentKeyShape!, components));\n    }\n    const f32Type = tensorTypeToWsglValueType(DataType.float, components);\n\n    const uniforms: UniformsArrayType = [\n      { name: 'M', type: 'u32' },\n      { name: 'K', type: 'u32' },\n      { name: 'N', type: 'u32' },\n      { name: 'num_heads', type: 'u32' },\n      { name: 'head_size', type: 'u32' },\n      { name: 'alpha', type: 'f32' as UniformDataElementType },\n      { name: 'past_sequence_length', type: 'u32' },\n      { name: 'kv_sequence_length', type: 'u32' },\n      { name: 'n_reps', type: 'u32' },\n    ];\n    return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n\n  var<workgroup> tileQ: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileK: array<${qInput.type.storage}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, ...outputVars)}\n  ${shaderHelper.mainStart([TILE_SIZE, TILE_SIZE, 1])}\n    // x holds the N and y holds the M\n    let headIdx = workgroup_id.z % uniforms.num_heads;\n    let kvHeadIdx = ${nReps === 1 ? 'headIdx' : 'headIdx / uniforms.n_reps'};\n    let kv_num_heads = ${nReps === 1 ? 'uniforms.num_heads' : 'uniforms.num_heads / uniforms.n_reps'};\n    let batchIdx = workgroup_id.z / uniforms.num_heads;\n    let m = workgroup_id.y * TILE_SIZE;\n    let n = workgroup_id.x * TILE_SIZE;\n    let sequence_length = uniforms.M;\n    var total_sequence_length = uniforms.N;\n    ${initVarStub(seqLensInputVariable, totalSequenceLengthInputVariable, true)}\n    let absKvHeadIdx = batchIdx * kv_num_heads + kvHeadIdx;\n    let qOffset = workgroup_id.z * uniforms.M * uniforms.K + m * uniforms.K;\n    ${feedPastKey && presentKey ? 'let pastKeyOffset = absKvHeadIdx * uniforms.past_sequence_length * uniforms.K;' : ''};\n    let kOffset = absKvHeadIdx * uniforms.kv_sequence_length * uniforms.K;\n    ${presentKey ? 'let presentKeyOffset = absKvHeadIdx * uniforms.N * uniforms.K;' : ''}\n    var value = ${f32Type}(0);\n    for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n      if (global_id.y < uniforms.M && w + local_id.x < uniforms.K) {\n        tileQ[TILE_SIZE * local_id.y + local_id.x] = q[qOffset + local_id.y * uniforms.K + w + local_id.x];\n      }\n      if (n + local_id.y < uniforms.N && w + local_id.x < uniforms.K) {\n        var idx = TILE_SIZE * local_id.y + local_id.x;\n      ${(() => {\n        if (feedPastKey && presentKey) {\n          return `\n              if (n + local_id.y < past_sequence_length) {\n                tileK[idx] = past_key[pastKeyOffset + (n + local_id.y) * uniforms.K + w + local_id.x];\n              } else if (n + local_id.y - past_sequence_length < uniforms.kv_sequence_length) {\n                tileK[idx] = key[kOffset + (n + local_id.y - past_sequence_length) * uniforms.K + w + local_id.x];\n              }`;\n        } else {\n          return `\n          if (n + local_id.y < uniforms.kv_sequence_length) {\n            tileK[idx] = key[kOffset + (n + local_id.y) * uniforms.K + w + local_id.x];\n          }`;\n        }\n      })()}\n      ${\n        presentKey\n          ? `if (n + local_id.y < present_sequence_length) {\n        present_key[presentKeyOffset + (n + local_id.y) * uniforms.K + w + local_id.x] = tileK[idx];\n      }`\n          : ''\n      }\n      }\n      workgroupBarrier();\n\n      for (var k: u32 = 0u; k < TILE_SIZE && w+k < uniforms.K; k++) {\n          value += ${f32Type}(tileQ[TILE_SIZE * local_id.y + k] * tileK[TILE_SIZE * local_id.x + k]);\n      }\n\n      workgroupBarrier();\n    }\n\n    if (global_id.y < uniforms.M && global_id.x < total_sequence_length) {\n      let headOffset = workgroup_id.z * uniforms.M * uniforms.N;\n      let outputIdx = headOffset + global_id.y * uniforms.N + global_id.x;\n      var sum: f32 = ${(() => {\n        switch (components) {\n          case 1:\n            return 'value';\n          case 2:\n            return 'value.x + value.y';\n          case 4:\n            return 'value.x + value.y + value.z + value.w';\n          default:\n            throw new Error(`Unsupported components: ${components}`);\n        }\n      })()};\n        output[outputIdx] = ${output.type.value} (sum * uniforms.alpha) + ${\n          attentionBias ? 'attention_bias[outputIdx]' : '0.0'\n        };\n    }\n  }`;\n  };\n  return {\n    name: 'AttentionProbs',\n    shaderCache: {\n      hint: `${components};${attentionBias !== undefined};${pastKey !== undefined};${outputCount}`,\n      inputDependencies,\n    },\n    getRunData: () => ({ outputs, dispatchGroup: dispatch, programUniforms }),\n    getShaderSource,\n  };\n};\n\nconst createVxAttentionScoreProgramInfo = (\n  outputCount: number,\n  probs: TensorView,\n  v: TensorView,\n  pastValue: TensorView | undefined,\n  params: AttentionParameters,\n  pastSequenceLength: number,\n  seqLens: TensorView | undefined = undefined,\n  totalSequenceLengthInput: TensorView | undefined = undefined,\n) => {\n  const totalSequenceLength = pastSequenceLength + params.kvSequenceLength;\n  const nReps = params.nReps ? params.nReps : 1;\n  const repeatedVHiddenSize = params.vHiddenSize * nReps;\n  const presentValue = outputCount > 1 && pastValue;\n  const kvNumHeads = params.kvNumHeads ? params.kvNumHeads : params.numHeads;\n  const presentValueShape = presentValue\n    ? [params.batchSize, kvNumHeads, totalSequenceLength, params.headSize]\n    : undefined;\n  const outputShape = [params.batchSize, params.sequenceLength, repeatedVHiddenSize];\n  const TILE_SIZE = 12;\n  const dispatch = {\n    x: Math.ceil(params.vHeadSize / TILE_SIZE),\n    y: Math.ceil(params.sequenceLength / TILE_SIZE),\n    z: params.batchSize * params.numHeads,\n  };\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: params.sequenceLength },\n    { type: DataType.uint32, data: totalSequenceLength },\n    { type: DataType.uint32, data: params.vHeadSize },\n    { type: DataType.uint32, data: params.numHeads },\n    { type: DataType.uint32, data: params.headSize },\n    { type: DataType.uint32, data: repeatedVHiddenSize },\n    { type: DataType.uint32, data: pastSequenceLength },\n    { type: DataType.uint32, data: params.kvSequenceLength },\n    { type: DataType.uint32, data: nReps },\n  ];\n  // Feed pastValue to the shader-code only if it is non-empty and presentValue is being produced\n  const feedPastValue = presentValue && pastValue && ShapeUtil.size(pastValue.dims) > 0;\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n  if (feedPastValue) {\n    inputDependencies.push('type');\n  }\n  if (seqLens) {\n    inputDependencies.push('type');\n  }\n  if (totalSequenceLengthInput) {\n    inputDependencies.push('type');\n  }\n  const outputs = [{ dims: outputShape, dataType: probs.dataType, gpuDataType: GpuDataType.default }];\n  if (presentValue) {\n    outputs.push({ dims: presentValueShape!, dataType: probs.dataType, gpuDataType: GpuDataType.default });\n  }\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const probsHelper = inputVariable('probs', probs.dataType, probs.dims);\n    const vHelper = inputVariable('v', v.dataType, v.dims);\n    const inputVars = [probsHelper, vHelper];\n    if (feedPastValue) {\n      inputVars.push(inputVariable('past_value', pastValue.dataType, pastValue.dims));\n    }\n    const seqLensInputVariable = seqLens ? inputVariable('seq_lens', seqLens.dataType, seqLens.dims) : undefined;\n    if (seqLens) {\n      inputVars.push(seqLensInputVariable!);\n    }\n    const totalSequenceLengthInputVariable = totalSequenceLengthInput\n      ? inputVariable('total_sequence_length_input', totalSequenceLengthInput.dataType, totalSequenceLengthInput.dims)\n      : undefined;\n    if (totalSequenceLengthInput) {\n      inputVars.push(totalSequenceLengthInputVariable!);\n    }\n    const output = outputVariable('output', probs.dataType, outputShape);\n    const outputVars = [output];\n    if (presentValue) {\n      outputVars.push(outputVariable('present_value', probs.dataType, presentValueShape!));\n    }\n    const uniforms: UniformsArrayType = [\n      { name: 'M', type: 'u32' },\n      { name: 'K', type: 'u32' },\n      { name: 'N', type: 'u32' },\n      { name: 'num_heads', type: 'u32' },\n      { name: 'head_size', type: 'u32' },\n      { name: 'v_hidden_size', type: 'u32' },\n      { name: 'past_sequence_length', type: 'u32' },\n      { name: 'kv_sequence_length', type: 'u32' },\n      { name: 'n_reps', type: 'u32' },\n    ];\n    return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n  var<workgroup> tileQ: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileV: array<${probsHelper.type.value}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, ...outputVars)}\n  ${shaderHelper.mainStart([TILE_SIZE, TILE_SIZE, 1])}\n   let headIdx = workgroup_id.z % uniforms.num_heads;\n   let batchIdx = workgroup_id.z / uniforms.num_heads;\n   let kvHeadIdx = ${nReps === 1 ? 'headIdx' : 'headIdx / uniforms.n_reps'};\n   let kv_num_heads = ${nReps === 1 ? 'uniforms.num_heads' : 'uniforms.num_heads / uniforms.n_reps'};\n   let m = global_id.y;\n   let n = global_id.x;\n   let sequence_length = uniforms.M;\n   var total_sequence_length = uniforms.K;\n   ${initVarStub(seqLensInputVariable, totalSequenceLengthInputVariable, true)}\n   let offsetA = workgroup_id.z * uniforms.M * uniforms.K + m * uniforms.K;\n   let absKvHeadIdx = batchIdx * kv_num_heads + kvHeadIdx; // kvHeadIdx is relative to the batch\n   ${feedPastValue && presentValue ? 'let pastValueOffset = absKvHeadIdx * uniforms.N * uniforms.past_sequence_length + n;' : ''};\n   let vOffset = absKvHeadIdx * uniforms.N * uniforms.kv_sequence_length + n;\n   ${presentValue ? 'let presentValueOffset = absKvHeadIdx * uniforms.N * uniforms.K + n;' : ''}\n   var value = ${probsHelper.type.storage}(0);\n   for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n      if (m < uniforms.M && w + local_id.x < uniforms.K) {\n        tileQ[TILE_SIZE * local_id.y + local_id.x] = probs[offsetA + w + local_id.x];\n      }\n      if (n < uniforms.N && w + local_id.y < uniforms.K) {\n        var idx = TILE_SIZE * local_id.y + local_id.x;\n        ${(() => {\n          if (feedPastValue && presentValue) {\n            return `\n        if (w + local_id.y < past_sequence_length) {\n          tileV[idx] = past_value[pastValueOffset + (w + local_id.y) * uniforms.N];\n        } else if (w + local_id.y - past_sequence_length < uniforms.kv_sequence_length) {\n          tileV[idx] = v[vOffset + (w + local_id.y - past_sequence_length) * uniforms.N];\n        }\n      `;\n          } else {\n            return `\n            if (w + local_id.y < uniforms.kv_sequence_length) {\n              tileV[idx] = v[vOffset + (w + local_id.y) * uniforms.N];\n            }`;\n          }\n        })()}\n        ${\n          presentValue\n            ? `\n            if (w + local_id.y < present_sequence_length) {\n          present_value[presentValueOffset + (w + local_id.y) * uniforms.N] = tileV[idx];\n        }`\n            : ''\n        }\n      }\n     workgroupBarrier();\n     for (var k: u32 = 0u; k < TILE_SIZE && w+k < total_sequence_length; k++) {\n       value += tileQ[TILE_SIZE * local_id.y + k] * tileV[TILE_SIZE * k + local_id.x];\n     }\n     workgroupBarrier();\n   }\n\n   // we need to transpose output from BNSH_v to BSND_v\n   if (m < uniforms.M && n < uniforms.N) {\n     let outputIdx = batchIdx * uniforms.M * uniforms.v_hidden_size + m * uniforms.v_hidden_size\n       + headIdx * uniforms.N + n;\n     output[outputIdx] = value;\n   }\n  }`;\n  };\n\n  return {\n    name: 'AttentionScore',\n    shaderCache: { hint: `${pastValue !== undefined};${outputCount}`, inputDependencies },\n    getRunData: () => ({ outputs, dispatchGroup: dispatch, programUniforms }),\n    getShaderSource,\n  };\n};\n\nexport const applyAttention = (\n  context: ComputeContext,\n  q: TensorView,\n  k: TensorView,\n  v: TensorView,\n  _maskIndex: TensorView | undefined,\n  _past: TensorView | undefined,\n  pastKey: TensorView | undefined,\n  pastValue: TensorView | undefined,\n  attentionBiasInput: TensorView | undefined,\n  parameters: AttentionParameters,\n  seqLens: TensorView | undefined = undefined,\n  totalSequenceLengthInput: TensorView | undefined = undefined,\n) => {\n  // Assumption is that presentKey/presentValue exists only if pastKey/pastValue exists.\n  const outputCount = Math.min(context.outputCount, 1 + (pastKey ? 1 : 0) + (pastValue ? 1 : 0));\n  // When there are no present key/value outputs (outputCount <= 1), ignore past to match CPU EP semantics.\n  const effectivePastKey = outputCount > 1 ? pastKey : undefined;\n  const effectivePastValue = outputCount > 1 ? pastValue : undefined;\n  const pastSequenceLength = outputCount > 1 ? parameters.pastSequenceLength : 0;\n  const totalSequenceLength = pastSequenceLength + parameters.kvSequenceLength;\n  const attentionBias =\n    attentionBiasInput && ShapeUtil.size(attentionBiasInput.dims) > 0 ? attentionBiasInput : undefined;\n\n  const inputsK = [q, k];\n  if (effectivePastKey && ShapeUtil.size(effectivePastKey.dims) > 0) {\n    inputsK.push(effectivePastKey);\n  }\n  if (attentionBias) {\n    inputsK.push(attentionBias);\n  }\n  if (seqLens) {\n    inputsK.push(seqLens);\n  }\n  if (totalSequenceLengthInput) {\n    inputsK.push(totalSequenceLengthInput);\n  }\n  // Run AttentionProbs\n  const probs = context.compute(\n    createAttentionProbsProgramInfo(\n      outputCount,\n      q,\n      k,\n      effectivePastKey,\n      attentionBias,\n      parameters,\n      pastSequenceLength,\n      seqLens,\n      totalSequenceLengthInput,\n    ),\n    { inputs: inputsK, outputs: outputCount > 1 ? [-1, 1] : [-1] },\n  )[0];\n\n  // Run Softmax\n  context.compute(\n    createInPlaceSoftmaxProgramInfo(\n      probs,\n      parameters.batchSize,\n      parameters.numHeads,\n      pastSequenceLength,\n      parameters.sequenceLength,\n      totalSequenceLength,\n      seqLens,\n      totalSequenceLengthInput,\n    ),\n    { inputs: seqLens && totalSequenceLengthInput ? [probs, seqLens, totalSequenceLengthInput] : [probs], outputs: [] },\n  );\n\n  // Run AttentionScore\n  const inputsV = [probs, v];\n  if (effectivePastValue && ShapeUtil.size(effectivePastValue.dims) > 0) {\n    inputsV.push(effectivePastValue);\n  }\n  if (seqLens) {\n    inputsV.push(seqLens);\n  }\n  if (totalSequenceLengthInput) {\n    inputsV.push(totalSequenceLengthInput);\n  }\n  context.compute(\n    createVxAttentionScoreProgramInfo(\n      outputCount,\n      probs,\n      v,\n      effectivePastValue,\n      parameters,\n      pastSequenceLength,\n      seqLens,\n      totalSequenceLengthInput,\n    ),\n    {\n      inputs: inputsV,\n      outputs: outputCount > 1 ? [0, 2] : [0],\n    },\n  );\n};\n\nconst prepare = (context: ComputeContext, parameters: AttentionParameters) => {\n  const outputShape = [parameters.batchSize, parameters.numHeads, parameters.sequenceLength, parameters.headSize];\n  const M = parameters.sequenceLength;\n  const K = parameters.inputHiddenSize;\n  const N = parameters.headSize;\n  const TILE_SIZE = 12;\n  const dispatch = {\n    x: Math.ceil(parameters.headSize / TILE_SIZE),\n    y: Math.ceil(parameters.sequenceLength / TILE_SIZE),\n    z: parameters.batchSize * parameters.numHeads,\n  };\n  const inputs = [context.inputs[0], context.inputs[1], context.inputs[2]];\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: M },\n    { type: DataType.uint32, data: K },\n    { type: DataType.uint32, data: N },\n    { type: DataType.uint32, data: parameters.numHeads },\n    { type: DataType.uint32, data: parameters.headSize },\n    { type: DataType.uint32, data: parameters.hiddenSize },\n    { type: DataType.uint32, data: parameters.hiddenSize + parameters.hiddenSize + parameters.vHiddenSize },\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const outputQ = outputVariable('output_q', inputs[0].dataType, outputShape);\n    const outputK = outputVariable('output_k', inputs[0].dataType, outputShape);\n    const outputV = outputVariable('output_v', inputs[0].dataType, outputShape);\n    const input = inputVariable('input', inputs[0].dataType, inputs[0].dims);\n    const weight = inputVariable('weight', inputs[1].dataType, inputs[1].dims);\n    const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims);\n    const dataType = input.type.storage;\n\n    const uniforms: UniformsArrayType = [\n      { name: 'M', type: 'u32' },\n      { name: 'K', type: 'u32' },\n      { name: 'N', type: 'u32' },\n      { name: 'num_heads', type: 'u32' },\n      { name: 'head_size', type: 'u32' },\n      { name: 'hidden_size', type: 'u32' },\n      { name: 'ldb', type: 'u32' },\n    ];\n    return `\n  const TILE_SIZE = ${TILE_SIZE}u;\n  var<workgroup> tileInput: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightQ: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightK: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  var<workgroup> tileWeightV: array<${dataType}, ${TILE_SIZE * TILE_SIZE}>;\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(input, weight, bias, outputQ, outputK, outputV)}\n  ${shaderHelper.mainStart([TILE_SIZE, TILE_SIZE, 1])}\n    let batchIndex = workgroup_id.z / uniforms.num_heads;\n    let headNumber = workgroup_id.z % uniforms.num_heads;\n    let m = global_id.y;\n    let n = global_id.x;\n\n    let inputOffset = batchIndex * (uniforms.M * uniforms.K) + m * uniforms.K;\n    let biasOffsetQ = headNumber * uniforms.head_size;\n    let biasOffsetK = uniforms.hidden_size + biasOffsetQ;\n    let biasOffsetV = uniforms.hidden_size + biasOffsetK;\n\n    var valueQ = ${dataType}(0);\n    var valueK = ${dataType}(0);\n    var valueV = ${dataType}(0);\n    for (var w: u32 = 0u; w < uniforms.K; w += TILE_SIZE) {\n      if (m < uniforms.M && w + local_id.x < uniforms.K) {\n        tileInput[TILE_SIZE * local_id.y + local_id.x] = input[inputOffset + w + local_id.x];\n      }\n      if (n < uniforms.N && w + local_id.y < uniforms.K) {\n        let offset = n + (w + local_id.y) * uniforms.ldb;\n        tileWeightQ[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetQ + offset];\n        tileWeightK[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetK + offset];\n        tileWeightV[TILE_SIZE * local_id.y + local_id.x] = weight[biasOffsetV + offset];\n      }\n      workgroupBarrier();\n      for (var k: u32 = 0u; k<TILE_SIZE && w+k < uniforms.K; k++) {\n        let inputTileOffset = TILE_SIZE * local_id.y + k;\n        let weightTileOffset = TILE_SIZE * k + local_id.x;\n        valueQ += tileInput[inputTileOffset] * tileWeightQ[weightTileOffset];\n        valueK += tileInput[inputTileOffset] * tileWeightK[weightTileOffset];\n        valueV += tileInput[inputTileOffset] * tileWeightV[weightTileOffset];\n      }\n\n      workgroupBarrier();\n    }\n\n    let headOffset = (m * uniforms.N + n) % uniforms.head_size;\n    valueQ += bias[headOffset + biasOffsetQ];\n    valueK += bias[headOffset + biasOffsetK];\n    valueV += bias[headOffset + biasOffsetV];\n\n    let offset = workgroup_id.z * uniforms.M * uniforms.N;\n    if (m < uniforms.M && n < uniforms.N) {\n      let outputIdx = offset + m * uniforms.N + n;\n      output_q[outputIdx] = valueQ;\n      output_k[outputIdx] = valueK;\n      output_v[outputIdx] = valueV;\n    }\n  }`;\n  };\n\n  return context.compute(\n    {\n      name: 'AttentionPrepare',\n      shaderCache: { inputDependencies: ['type', 'type', 'type'] },\n      getRunData: () => ({\n        outputs: [\n          { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: GpuDataType.default },\n          { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: GpuDataType.default },\n          { dims: outputShape, dataType: context.inputs[0].dataType, gpuDataType: GpuDataType.default },\n        ],\n        dispatchGroup: dispatch,\n        programUniforms,\n      }),\n      getShaderSource,\n    },\n    { inputs, outputs: [-1, -1, -1] },\n  );\n};\n\nexport const attention = (context: ComputeContext, attributes: AttentionAttrs): void => {\n  const params = validateAttentionInputs(context.inputs, attributes);\n\n  const [q, k, v] = prepare(context, params);\n\n  return applyAttention(\n    context,\n    q,\n    k,\n    v,\n    context.inputs[4],\n    undefined,\n    undefined,\n    undefined,\n    context.inputs[5],\n    params,\n  );\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { env } from 'onnxruntime-common';\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo } from '../types';\n\nimport { createTensorShapeVariables, getMaxComponents, inputVariable, outputVariable, ShaderHelper } from './common';\n\nexport interface BatchNormAttributes extends AttributeWithCacheKey {\n  readonly epsilon: number;\n  readonly momentum: number;\n  readonly spatial: boolean;\n  readonly trainingMode: boolean;\n  readonly format: 'NHWC' | 'NCHW';\n  readonly outputCount: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: BatchNormAttributes): void => {\n  if (!inputs || inputs.length !== 5) {\n    throw new Error('BatchNormalization requires 5 inputs');\n  }\n\n  const checkShapeEqual = (actual: readonly number[], expected: readonly number[], message: string) => {\n    const r = expected.length;\n    if (r !== actual.length) {\n      throw new Error(`${message}: num dimensions != ${r}`);\n    }\n    expected.forEach((v, i) => {\n      if (v !== actual[i]) {\n        throw new Error(`${message}: dim[${i}] do not match`);\n      }\n    });\n  };\n\n  if (inputs[0].dims.length > 1) {\n    const shape =\n      attributes.format === 'NHWC'\n        ? attributes.spatial\n          ? inputs[0].dims.slice(-1)\n          : inputs[0].dims.slice(-1).concat(inputs[0].dims.slice(1, inputs[0].dims.length - 1))\n        : inputs[0].dims.slice(1, attributes.spatial ? 2 : undefined);\n    checkShapeEqual(inputs[1].dims, shape, 'Invalid input scale');\n    checkShapeEqual(inputs[2].dims, shape, 'Invalid input B');\n    checkShapeEqual(inputs[3].dims, shape, 'Invalid input mean');\n    checkShapeEqual(inputs[4].dims, shape, 'Invalid input var');\n  } else {\n    checkShapeEqual(inputs[1].dims, [1], 'Invalid input scale');\n    checkShapeEqual(inputs[2].dims, [1], 'Invalid input B');\n    checkShapeEqual(inputs[3].dims, [1], 'Invalid input mean');\n    checkShapeEqual(inputs[4].dims, [1], 'Invalid input var');\n  }\n};\n\nconst createBatchNormInferenceProgramInfo = (\n  inputs: readonly TensorView[],\n  attributes: BatchNormAttributes,\n): ProgramInfo => {\n  const { epsilon, spatial, format } = attributes;\n  const yShape = inputs[0].dims;\n  const components = spatial ? getMaxComponents(yShape[yShape.length - 1]) : 1;\n  const cComponents = format === 'NHWC' && yShape.length > 1 ? components : 1;\n  const outputSize = ShapeUtil.size(yShape) / components;\n  // Only support uniforms for opset version >= 9 (spatial = true).\n  const useShapesUniforms = spatial;\n  const shapeOrRank = useShapesUniforms ? yShape.length : yShape;\n  const x = inputVariable('x', inputs[0].dataType, inputs[0].dims, components);\n  const scale = inputVariable('scale', inputs[1].dataType, inputs[1].dims, cComponents);\n  const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims, cComponents);\n  const inputMean = inputVariable('inputMean', inputs[3].dataType, inputs[3].dims, cComponents);\n  const inputVar = inputVariable('inputVar', inputs[4].dataType, inputs[4].dims, cComponents);\n  const y = outputVariable('y', inputs[0].dataType, shapeOrRank, components);\n  // TODO: support inputs with different data type. Current we need to make sure all inputs have the same data type.\n  // Otherwise, the shader compilation will fail.\n  const calcCOffset = (): string => {\n    let cOffset = '';\n    if (spatial) {\n      cOffset = `let cOffset = ${\n        yShape.length === 1\n          ? '0u'\n          : format === 'NHWC'\n            ? `outputIndices[${yShape.length - 1}] / ${components}`\n            : 'outputIndices[1]'\n      };`;\n    } else {\n      if (format === 'NCHW') {\n        cOffset = `\n            ${y.indicesSet('outputIndices', '0', '0')}\n            let cOffset = ${y.indicesToOffset('outputIndices')};`;\n      } else {\n        // update C channel.\n        cOffset = `var cIndices = ${scale.type.indices}(0);\n                       cIndices[0] = outputIndices[${yShape.length - 1}];`;\n        // update D1 x ... x Dn channels.\n        for (let i = 1; i < scale.rank; i++) {\n          cOffset += `cIndices[${i}] = outputIndices[${i}];`;\n        }\n        cOffset += `let cOffset = ${scale.indicesToOffset('cIndices')};`;\n      }\n    }\n    return cOffset;\n  };\n  const getInferenceModeShaderSource = (helper: ShaderHelper) => `\n  const epsilon = ${epsilon};\n  ${helper.registerUniform('outputSize', 'u32').declareVariables(x, scale, bias, inputMean, inputVar, y)}\n  ${helper.mainStart()}\n  ${helper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n    var outputIndices = ${y.offsetToIndices(`global_idx * ${components}`)};\n    ${calcCOffset()}\n    let scale = ${scale.getByOffset('cOffset')};\n    let bias = ${bias.getByOffset('cOffset')};\n    let inputMean = ${inputMean.getByOffset('cOffset')};\n    let inputVar = ${inputVar.getByOffset('cOffset')};\n    let x = ${x.getByOffset('global_idx')};\n    let value = (x - inputMean) * inverseSqrt(inputVar + epsilon) * scale + bias;\n    ${y.setByOffset('global_idx', 'value')}\n  }`;\n  return {\n    name: 'BatchNormalization',\n    shaderCache: {\n      hint: `${attributes.epsilon}_${attributes.format}_${spatial}_${components}`,\n      inputDependencies: useShapesUniforms ? ['rank', 'type', 'type', 'type', 'type'] : undefined,\n    },\n    getShaderSource: getInferenceModeShaderSource,\n    getRunData: () => ({\n      outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms: useShapesUniforms\n        ? [{ type: DataType.uint32, data: outputSize }, ...createTensorShapeVariables(yShape)]\n        : [{ type: DataType.uint32, data: outputSize }],\n    }),\n  };\n};\n\nexport const parseBatchNormAttributes = (attributes: Record<string, unknown>): BatchNormAttributes =>\n  createAttributeWithCacheKey(attributes as Omit<BatchNormAttributes, keyof AttributeWithCacheKey>);\n\nexport const batchNorm = (context: ComputeContext, attributes: Record<string, unknown>): void => {\n  const { inputs, outputCount } = context;\n  const updatedAttributes = parseBatchNormAttributes({ ...attributes, outputCount });\n  if (env.webgpu.validateInputContent) {\n    validateInputs(inputs, updatedAttributes);\n  }\n  if (attributes.trainingMode) {\n    throw new Error('BatchNormalization trainingMode is not supported yet.');\n  } else {\n    context.compute(createBatchNormInferenceProgramInfo(inputs, updatedAttributes));\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { ComputeContext, ProgramInfo } from '../types';\n\nimport { inputVariable, outputVariable, ShaderHelper } from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (inputs[0].dims.length !== 3) {\n    throw new Error('input should have 3 dimensions');\n  }\n\n  if (![320, 640, 1280].includes(inputs[0].dims[2])) {\n    throw new Error('number of channels should be 320, 640 or 1280');\n  }\n\n  if (inputs[1].dims.length !== 1) {\n    throw new Error('bias is expected to have 1 dimensions');\n  }\n\n  if (inputs[0].dims[2] !== inputs[1].dims[0]) {\n    throw new Error('last dimension of input and bias are not the same');\n  }\n};\n\nconst createBiasAddProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const outputShape = inputs[0].dims;\n\n  const channels = inputs[0].dims[2];\n  // since channel number can be only 320/640/1280, it's always divisible by 4\n  const outputSize = ShapeUtil.size(outputShape) / 4;\n\n  const dataType = inputs[0].dataType;\n  const input = inputVariable('input', dataType, outputShape, 4);\n  const bias = inputVariable('bias', dataType, [channels], 4);\n  const residual = inputVariable('residual', dataType, outputShape, 4);\n  const output = outputVariable('output', dataType, outputShape, 4);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  const channels = ${channels}u / 4;\n  ${shaderHelper.declareVariables(input, bias, residual, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n    let value = ${input.getByOffset('global_idx')}\n      + ${bias.getByOffset('global_idx % channels')} + ${residual.getByOffset('global_idx')};\n    ${output.setByOffset('global_idx', 'value')}\n  }`;\n\n  return {\n    name: 'BiasAdd',\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n    }),\n    getShaderSource,\n  };\n};\n\nexport const biasAdd = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createBiasAddProgramInfo(context.inputs));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramUniform } from '../types';\n\nimport {\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  tensorTypeToWsglValueType,\n  UniformDataElementType,\n  UniformsArrayType,\n} from './common';\n\ntype BuiltinFunctionName = string;\ntype ElementwiseCustomExpression = (expression: string) => string;\ntype ElementwiseFunctionCall = BuiltinFunctionName | ElementwiseCustomExpression;\n\nconst createElementwiseProgramShader = (\n  shaderHelper: ShaderHelper,\n  datasize: number,\n  inputDataType: number,\n  outputDataType: number,\n  funcCall: ElementwiseFunctionCall,\n  additionalImplementation?: string,\n  additionalUniformsType?: UniformsArrayType,\n): string => {\n  const vecSize = Math.ceil(datasize / 4);\n\n  let expression = '';\n  if (typeof funcCall === 'string') {\n    expression = `${funcCall}(a)`;\n  } else {\n    expression = funcCall('a');\n  }\n\n  const input = inputVariable('inputData', inputDataType, [vecSize], 4);\n  const output = outputVariable('outputData', outputDataType, [vecSize], 4);\n  const uniforms: UniformsArrayType = [{ name: 'vec_size', type: 'u32' }];\n  if (additionalUniformsType) {\n    uniforms.push(...additionalUniformsType);\n  }\n\n  return `\n      ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}\n\n  ${additionalImplementation ?? ''}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n\n    let a = ${input.getByOffset('global_idx')};\n    ${output.setByOffset('global_idx', expression)}\n  }`;\n};\n\nconst createElementwiseProgramInfo = (\n  input: TensorView,\n  name: string,\n  funcCall: ElementwiseFunctionCall,\n  additionalImplementation?: string,\n  cacheKey?: string,\n  outputDataType: number = input.dataType,\n  additionalUniforms?: ProgramUniform[],\n  additionalUniformsType?: UniformsArrayType,\n): ProgramInfo => {\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: Math.ceil(ShapeUtil.size(input.dims) / 4) },\n  ];\n  if (additionalUniforms) {\n    programUniforms.push(...additionalUniforms);\n  }\n\n  return {\n    name,\n    shaderCache: { hint: cacheKey, inputDependencies: ['type'] },\n    getShaderSource: (shaderHelper) =>\n      createElementwiseProgramShader(\n        shaderHelper,\n        ShapeUtil.size(input.dims),\n        input.dataType,\n        outputDataType,\n        funcCall,\n        additionalImplementation,\n        additionalUniformsType,\n      ),\n    getRunData: (inputTensors) => ({\n      outputs: [{ dims: input.dims, dataType: outputDataType }],\n      dispatchGroup: {\n        x: Math.ceil(ShapeUtil.size(inputTensors[0].dims) / 64 /* workgroup size */ / 4 /* vec size */),\n      },\n      programUniforms,\n    }),\n  };\n};\n\nexport const abs = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Abs', 'abs'));\n};\n\nexport const acos = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Acos', 'acos'));\n};\n\nexport const acosh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Acosh', 'acosh'));\n};\n\nexport const asin = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Asin', 'asin'));\n};\n\nexport const asinh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Asinh', 'asinh'));\n};\n\nexport const atan = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Atan', 'atan'));\n};\nexport const atanh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Atanh', 'atanh'));\n};\n\nexport interface CastAttributes extends AttributeWithCacheKey {\n  readonly to: number;\n  readonly saturate?: boolean;\n}\n\nexport const parseCastAttributes = (attributes: Record<string, unknown>): CastAttributes =>\n  createAttributeWithCacheKey(attributes as { to: number });\n\nexport const cast = (context: ComputeContext, attributes: CastAttributes): void => {\n  let func: ElementwiseFunctionCall;\n  switch (attributes.to) {\n    case DataType.float16:\n      func = 'vec4<f16>';\n      break;\n    case DataType.float:\n      func = 'vec4<f32>';\n      break;\n    case DataType.uint32:\n      func = 'vec4<u32>';\n      break;\n    case DataType.int32:\n      func = 'vec4<i32>';\n      break;\n    case DataType.bool:\n      func = 'vec4<bool>';\n      break;\n    default:\n      throw new RangeError(`not supported type (specified in attribute 'to' from 'Cast' operator): ${attributes.to}`);\n  }\n  context.compute(\n    createElementwiseProgramInfo(context.inputs[0], 'Cast', func, undefined, attributes.cacheKey, attributes.to),\n  );\n};\n\nexport interface ClipAttributes extends AttributeWithCacheKey {\n  readonly min: number;\n  readonly max: number;\n}\n\nconst generateClipAttributesFromInputs = (inputs: readonly TensorView[]): ClipAttributes => {\n  let min: number;\n  let max: number;\n  const hasMin = inputs.length >= 2 && inputs[1].data !== 0;\n  const hasMax = inputs.length >= 3 && inputs[2].data !== 0;\n\n  switch (inputs[0].dataType) {\n    case DataType.float:\n      min = hasMin ? inputs[1].getFloat32Array()[0] : -3.4028234663852886e38;\n      max = hasMax ? inputs[2].getFloat32Array()[0] : 3.4028234663852886e38;\n      break;\n    case DataType.float16:\n      min = hasMin ? inputs[1].getUint16Array()[0] : 64511; // uint16(64511) <-> float16(-65504.0)\n      max = hasMax ? inputs[2].getUint16Array()[0] : 31743; // uint16(31743) <-> float16(65504.0)\n      break;\n    default:\n      throw new Error('Unsupport data type');\n  }\n\n  return createAttributeWithCacheKey({ min, max });\n};\n\nexport const clip = (context: ComputeContext, clipAttributes: ClipAttributes): void => {\n  const attributes = clipAttributes ? clipAttributes : generateClipAttributesFromInputs(context.inputs);\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(\n    createElementwiseProgramInfo(\n      context.inputs[0],\n      'Clip',\n      (a) => `clamp(${a}, vec4<${dataType}>(uniforms.min), vec4<${dataType}>(uniforms.max))`,\n      undefined,\n      attributes.cacheKey,\n      undefined,\n      [\n        { type: context.inputs[0].dataType, data: attributes.min },\n        { type: context.inputs[0].dataType, data: attributes.max },\n      ],\n      [\n        { name: 'min', type: dataType as UniformDataElementType },\n        { name: 'max', type: dataType as UniformDataElementType },\n      ],\n    ),\n    { inputs: [0] },\n  );\n};\n\nexport const ceil = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Ceil', 'ceil'));\n};\n\nexport const cos = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Cos', 'cos'));\n};\n\nexport const cosh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Cosh', 'cosh'));\n};\n\nexport interface AlphaAttributes extends AttributeWithCacheKey {\n  readonly alpha: number;\n}\n\nexport const parseAlphaAttributes = (attributes: Record<string, unknown>): AlphaAttributes =>\n  createAttributeWithCacheKey(attributes as { alpha: number });\n\nexport const elu = (context: ComputeContext, attributes: AlphaAttributes): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(\n    createElementwiseProgramInfo(\n      context.inputs[0],\n      'Elu',\n      (a) => `elu_vf32(${a})`,\n      `\n  const elu_alpha_ = ${dataType}(${attributes.alpha});\n\n  fn elu_f32(a: ${dataType}) -> ${dataType} {\n  return select((exp(a) - 1.0) * elu_alpha_, a, a >= 0.0);\n  }\n\n  fn elu_vf32(v: vec4<${dataType}>) -> vec4<${dataType}> {\n  return vec4(elu_f32(v.x), elu_f32(v.y), elu_f32(v.z), elu_f32(v.w));\n  }`,\n      attributes.cacheKey,\n    ),\n  );\n};\n\nexport const erfImpl = (varType = 'f32') => `\nconst r0: ${varType} = 0.3275911;\nconst r1: ${varType} = 0.254829592;\nconst r2: ${varType} = -0.284496736;\nconst r3: ${varType} = 1.421413741;\nconst r4: ${varType} = -1.453152027;\nconst r5: ${varType} = 1.061405429;\n\nfn erf_vf32(v: vec4<${varType}>) -> vec4<${varType}> {\n  let absv = abs(v);\n  let x = 1.0 / (1.0 + r0 * absv);\n  return sign(v) * (1.0 - ((((r5 * x + r4) * x + r3) * x + r2) * x + r1) * x * exp(-absv * absv));\n}`;\n\nexport const erf = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Erf', (a) => `erf_vf32(${a})`, erfImpl(dataType)));\n};\n\nexport const exp = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Exp', 'exp'));\n};\n\nexport const floor = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Floor', 'floor'));\n};\n\nexport const gelu = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(\n    createElementwiseProgramInfo(\n      context.inputs[0],\n      'Gelu',\n      (a) => `0.5 * ${a} * (1.0 + erf_vf32(${a} * 0.7071067811865475))`,\n      erfImpl(dataType),\n    ),\n  );\n};\n\nexport const leakyRelu = (context: ComputeContext, attributes: AlphaAttributes): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(\n    createElementwiseProgramInfo(\n      context.inputs[0],\n      'LeakyRelu',\n      (a) => `select(leaky_relu_alpha_ * ${a}, ${a}, ${a} >= vec4<${dataType}>(0.0))`,\n      `const leaky_relu_alpha_ = ${dataType}(${attributes.alpha});`,\n      attributes.cacheKey,\n    ),\n  );\n};\n\nexport const not = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Not', (a) => `!${a}`));\n};\n\nexport const neg = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Neg', (a) => `-${a}`));\n};\n\nexport const reciprocal = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Reciprocal', (a) => `1.0/${a}`));\n};\n\nexport const relu = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(\n    createElementwiseProgramInfo(\n      context.inputs[0],\n      'Relu',\n      (a) => `select(vec4<${dataType}>(0.0), ${a}, ${a} > vec4<${dataType}>(0.0))`,\n    ),\n  );\n};\n\nexport const sigmoid = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sigmoid', (a) => `(1.0 / (1.0 + exp(-${a})))`));\n};\n\nexport interface HardSigmoidAttributes extends AttributeWithCacheKey {\n  readonly alpha: number;\n  readonly beta: number;\n}\n\nexport const parseHardSigmoidAttributes = (attributes: Record<string, unknown>): HardSigmoidAttributes =>\n  createAttributeWithCacheKey(\n    attributes as {\n      alpha: number;\n      beta: number;\n    },\n  );\n\nexport const hardSigmoid = (context: ComputeContext, attributes: HardSigmoidAttributes): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(\n    createElementwiseProgramInfo(\n      context.inputs[0],\n      'HardSigmoid',\n      (a) =>\n        `max(vec4<${dataType}>(0.0), min(vec4<${dataType}>(1.0), ${attributes.alpha} * ${a} + vec4<${dataType}>(${attributes.beta})))`,\n      undefined,\n      attributes.cacheKey,\n    ),\n  );\n};\n\nexport const sin = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sin', 'sin'));\n};\n\nexport const sinh = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sinh', 'sinh'));\n};\n\nexport const sqrt = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Sqrt', 'sqrt'));\n};\n\nexport const tan = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Tan', 'tan'));\n};\n\nexport const tanhExpression = (a: string) => `sign(${a}) * (1 - exp(-2 * abs(${a}))) / (1 + exp(-2 * abs(${a})))`;\n\nexport const tanh = (context: ComputeContext): void => {\n  // TODO: revisit after https://github.com/gpuweb/gpuweb/issues/4458 is resolved\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Tanh', tanhExpression));\n};\n\nexport const fastGeluImpl = (varType = 'f32') => `\nconst fast_gelu_a: ${varType} = 0.5;\nconst fast_gelu_b: ${varType} = 0.7978845608028654;\nconst fast_gelu_c: ${varType} = 0.035677408136300125;\n\nfn tanh_v(v: vec4<${varType}>) -> vec4<${varType}> {\n  return ${tanhExpression('v')};\n}\n`;\n\nexport const fastGeluExpression = (x: string) =>\n  `(fast_gelu_a + fast_gelu_a * tanh_v(${x} * (fast_gelu_c * ${x} * ${x} + fast_gelu_b))) * ${x}`;\n\nexport const fastGelu = (context: ComputeContext): void => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(\n    createElementwiseProgramInfo(\n      context.inputs[0],\n      'FastGelu',\n      fastGeluExpression,\n      fastGeluImpl(dataType),\n      undefined,\n      context.inputs[0].dataType,\n    ),\n  );\n};\n\nexport const thresholdedRelu = (context: ComputeContext, attributes: AlphaAttributes): number => {\n  const dataType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(\n    createElementwiseProgramInfo(\n      context.inputs[0],\n      'ThresholdedRelu',\n      (a) => `select(vec4<${dataType}>(0.0), ${a}, ${a} > thresholded_relu_alpha_)`,\n      `const thresholded_relu_alpha_ = vec4<${dataType}>(${attributes.alpha});`,\n      attributes.cacheKey,\n    ),\n  );\n  return 0;\n};\n\nexport const log = (context: ComputeContext): void => {\n  context.compute(createElementwiseProgramInfo(context.inputs[0], 'Log', 'log'));\n};\n\nexport const quickGeluImpl = (varType: string, alpha: number) => `\nconst alpha = vec4<${varType}>(${alpha});\nconst one = ${varType}(1.0);\nconst zero = ${varType}(0.0);\n\nfn quick_gelu_impl(x: vec4<${varType}>) -> vec4<${varType}> {\n  let v = x *alpha;\n  var x1 : vec4<${varType}>;\n  for (var i = 0; i < 4; i = i + 1) {\n    if (v[i] >= zero) {\n      x1[i] = one / (one + exp(-v[i]));\n    } else {\n      x1[i] = one - one / (one + exp(v[i]));\n    }\n  }\n  return x * x1;\n}\n`;\n\nexport const quickGeluExpression = (x: string) => `quick_gelu_impl(${x})`;\n\nexport const quickgelu = (context: ComputeContext, attributes: AlphaAttributes): void => {\n  const dType = tensorTypeToWsglValueType(context.inputs[0].dataType);\n  context.compute(\n    createElementwiseProgramInfo(\n      context.inputs[0],\n      'QuickGelu',\n      quickGeluExpression,\n      quickGeluImpl(dType, attributes.alpha),\n      attributes.cacheKey,\n      context.inputs[0].dataType,\n    ),\n  );\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { ComputeContext, ProgramInfo } from '../types';\n\nimport { inputVariable, outputVariable, ShaderHelper, tensorTypeToWsglStorageType } from './common';\nimport { erfImpl } from './unary-op';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (inputs[0].dims.length !== 3) {\n    throw new Error('input should have 3 dimensions');\n  }\n\n  if (![2560, 5120, 10240].includes(inputs[0].dims[2])) {\n    throw new Error('hidden state should be 2560, 5120 or 10240');\n  }\n\n  if (inputs[1].dims.length !== 1) {\n    throw new Error('bias is expected to have 1 dimensions');\n  }\n\n  if (inputs[0].dims[2] !== inputs[1].dims[0]) {\n    throw new Error('last dimension of input and bias are not the same');\n  }\n};\n\nconst createBiasSplitGeluProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const outputShape = inputs[0].dims.slice();\n  outputShape[2] = outputShape[2] / 2;\n\n  const input = inputVariable('input', inputs[0].dataType, inputs[0].dims, 4);\n  const bias = inputVariable('bias', inputs[0].dataType, [inputs[0].dims[2]], 4);\n  const output = outputVariable('output', inputs[0].dataType, outputShape, 4);\n\n  const outputSize = ShapeUtil.size(outputShape) / 4;\n  const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  const M_SQRT2 = sqrt(2.0);\n  const halfChannels = ${inputs[0].dims[2] / 4 / 2}u;\n\n  ${shaderHelper.declareVariables(input, bias, output)}\n\n  ${erfImpl(dataType)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes(outputSize)}\n    let biasIdx = global_idx % halfChannels;\n    let batchIndex = global_idx / halfChannels;\n    let inputOffset = biasIdx + batchIndex * halfChannels * 2;\n    let valueLeft = input[inputOffset] + bias[biasIdx];\n    let valueRight = input[inputOffset + halfChannels] + bias[biasIdx + halfChannels];\n    let geluRight = valueRight * 0.5 * (erf_vf32(valueRight / M_SQRT2) + 1);\n\n    ${output.setByOffset('global_idx', 'valueLeft * geluRight')}\n  }`;\n\n  return {\n    name: 'BiasSplitGelu',\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n    }),\n    getShaderSource,\n  };\n};\n\nexport const biasSplitGelu = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createBiasSplitGeluProgramInfo(context.inputs));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { BroadcastUtil, ShapeUtil } from '../../util';\nimport { ComputeContext, ProgramInfo } from '../types';\n\nimport { createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper } from './common';\n\ntype BuiltinFunctionName = string;\ntype BinaryCustomExpression = (expressionA: string, expressionB: string) => string;\ntype BinaryFunctionCall =\n  | BuiltinFunctionName\n  | BinaryCustomExpression\n  | {\n      scalar: BinaryCustomExpression;\n      vector: BinaryCustomExpression;\n    };\n\nconst createBinaryOpProgramShader = (\n  shaderHelper: ShaderHelper,\n  dimsA: readonly number[],\n  dimsB: readonly number[],\n  dimsOutput: readonly number[],\n  vectorize: boolean,\n  doBroadcast: boolean,\n  sharedDimensionDivisibleBy4: boolean,\n  funcCall: BinaryFunctionCall,\n  typeA: number,\n  typeB: number,\n  typeOutput: number,\n  additionalImplementation?: string,\n) => {\n  let expressionScalar: BinaryCustomExpression;\n  let expressionVector: BinaryCustomExpression;\n  if (typeof funcCall === 'string') {\n    expressionScalar = expressionVector = (a, b) => `${funcCall}((${a}),(${b}))`;\n  } else if (typeof funcCall === 'function') {\n    expressionScalar = expressionVector = funcCall;\n  } else {\n    expressionScalar = funcCall.scalar;\n    expressionVector = funcCall.vector;\n  }\n\n  const output = outputVariable('outputData', typeOutput, dimsOutput.length, 4);\n  const a = inputVariable('aData', typeA, dimsA.length, 4);\n  const b = inputVariable('bData', typeB, dimsB.length, 4);\n\n  let assignment: string;\n  if (vectorize) {\n    if (doBroadcast) {\n      const isAOneElement = ShapeUtil.size(dimsA) === 1;\n      const isBOneElement = ShapeUtil.size(dimsB) === 1;\n      const aLastDimDivisibleBy4 = dimsA.length > 0 && dimsA[dimsA.length - 1] % 4 === 0;\n      const bLastDimDivisibleBy4 = dimsB.length > 0 && dimsB[dimsB.length - 1] % 4 === 0;\n      if (isAOneElement || isBOneElement) {\n        assignment = output.setByOffset(\n          'global_idx',\n          expressionVector(\n            isAOneElement ? `${a.type.value}(${a.getByOffset('0')}.x)` : a.getByOffset('global_idx'),\n            isBOneElement ? `${b.type.value}(${b.getByOffset('0')}.x)` : b.getByOffset('global_idx'),\n          ),\n        );\n      } else {\n        assignment = `\n            let outputIndices = ${output.offsetToIndices('global_idx * 4u')};\n            let offsetA = ${a.broadcastedIndicesToOffset('outputIndices', output)};\n            let offsetB = ${b.broadcastedIndicesToOffset('outputIndices', output)};\n            ${output.setByOffset(\n              'global_idx',\n              expressionVector(\n                sharedDimensionDivisibleBy4 || aLastDimDivisibleBy4\n                  ? a.getByOffset('offsetA / 4u')\n                  : `${a.type.value}(${a.getByOffset('offsetA / 4u')}[offsetA % 4u])`,\n                sharedDimensionDivisibleBy4 || bLastDimDivisibleBy4\n                  ? b.getByOffset('offsetB / 4u')\n                  : `${b.type.value}(${b.getByOffset('offsetB / 4u')}[offsetB % 4u])`,\n              ),\n            )}\n          `;\n      }\n    } else {\n      assignment = output.setByOffset(\n        'global_idx',\n        expressionVector(a.getByOffset('global_idx'), b.getByOffset('global_idx')),\n      );\n    }\n  } else {\n    if (!doBroadcast) {\n      throw new Error('no necessary to use scalar implementation for element-wise binary op implementation.');\n    }\n\n    const singleAssignment = (resStr: string, x: number, typeCast = '') => {\n      const expressionA = `aData[indexA${x}][componentA${x}]`;\n      const expressionB = `bData[indexB${x}][componentB${x}]`;\n      return `\n            let outputIndices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)};\n            let offsetA${x} = ${a.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n            let offsetB${x} = ${b.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n            let indexA${x} = offsetA${x} / 4u;\n            let indexB${x} = offsetB${x} / 4u;\n            let componentA${x} = offsetA${x} % 4u;\n            let componentB${x} = offsetB${x} % 4u;\n            ${resStr}[${x}] = ${typeCast}(${expressionScalar(expressionA, expressionB)});\n          `;\n    };\n    if (typeOutput === DataType.bool) {\n      assignment = `\n            var data = vec4<u32>(0);\n            ${singleAssignment('data', 0, 'u32')}\n            ${singleAssignment('data', 1, 'u32')}\n            ${singleAssignment('data', 2, 'u32')}\n            ${singleAssignment('data', 3, 'u32')}\n            outputData[global_idx] = dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(data));`;\n    } else {\n      assignment = `\n            ${singleAssignment('outputData[global_idx]', 0)}\n            ${singleAssignment('outputData[global_idx]', 1)}\n            ${singleAssignment('outputData[global_idx]', 2)}\n            ${singleAssignment('outputData[global_idx]', 3)}\n          `;\n    }\n  }\n\n  return `\n        ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(a, b, output)}\n\n        ${additionalImplementation ?? ''}\n\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n        ${assignment}\n      }`;\n};\n\nconst createBinaryOpProgramInfo = (\n  name: string,\n  cacheKey: string,\n  a: TensorView,\n  b: TensorView,\n  funcCall: BinaryFunctionCall,\n  additionalImplementation?: string,\n  outputDataType: number = a.dataType,\n): ProgramInfo => {\n  const aDims = a.dims.map(Number);\n  const bDims = b.dims.map(Number);\n  const isBroadcast = !ShapeUtil.areEqual(aDims, bDims);\n  let outputShape = aDims;\n  let outputSize = ShapeUtil.size(aDims);\n\n  let vectorize = false;\n  let sharedDimensionDivisibleBy4 = false;\n\n  // TODO: deal with zero-sized tensors (eg. dims=[1,0])\n  const cacheKeyAux = [isBroadcast];\n  if (isBroadcast) {\n    const calculatedShape = BroadcastUtil.calcShape(aDims, bDims, false);\n    if (!calculatedShape) {\n      throw new Error(\"Can't perform binary op on the given tensors\");\n    }\n    outputShape = calculatedShape.slice();\n    outputSize = ShapeUtil.size(outputShape);\n    const isAOneElement = ShapeUtil.size(aDims) === 1;\n    const isBOneElement = ShapeUtil.size(bDims) === 1;\n    const aLastDimDivisibleBy4 = aDims.length > 0 && aDims[aDims.length - 1] % 4 === 0;\n    const bLastDimDivisibleBy4 = bDims.length > 0 && bDims[bDims.length - 1] % 4 === 0;\n    cacheKeyAux.push(isAOneElement);\n    cacheKeyAux.push(isBOneElement);\n    cacheKeyAux.push(aLastDimDivisibleBy4);\n    cacheKeyAux.push(bLastDimDivisibleBy4);\n    // check whether vectorize can be enabled\n    let sharedDimension = 1;\n    for (let i = 1; i < outputShape.length; i++) {\n      const dimA = aDims[aDims.length - i];\n      const dimB = bDims[bDims.length - i];\n      if (dimA === dimB) {\n        sharedDimension *= dimA;\n      } else {\n        break;\n      }\n    }\n    if (sharedDimension % 4 === 0) {\n      sharedDimensionDivisibleBy4 = true;\n      vectorize = true;\n    } else if (isAOneElement || isBOneElement || aLastDimDivisibleBy4 || bLastDimDivisibleBy4) {\n      vectorize = true;\n    }\n  } else {\n    // element-wise\n    vectorize = true;\n  }\n  cacheKeyAux.push(vectorize);\n\n  return {\n    name,\n    shaderCache: {\n      hint: cacheKey + cacheKeyAux.map((x) => x.toString()).join('_'),\n      inputDependencies: ['rank', 'rank'],\n    },\n    getShaderSource: (shaderHelper) =>\n      createBinaryOpProgramShader(\n        shaderHelper,\n        aDims,\n        bDims,\n        outputShape,\n        vectorize,\n        isBroadcast,\n        sharedDimensionDivisibleBy4,\n        funcCall,\n        a.dataType,\n        b.dataType,\n        outputDataType,\n        additionalImplementation,\n      ),\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: outputDataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */ / 4 /* component size */) },\n      programUniforms: [\n        { type: DataType.uint32, data: Math.ceil(ShapeUtil.size(outputShape) / 4) },\n        ...createTensorShapeVariables(aDims, bDims, outputShape),\n      ],\n    }),\n  };\n};\n\nconst runBinaryOp = (\n  context: ComputeContext,\n  name: string,\n  funcCall: BinaryFunctionCall,\n  additionalImplementation?: string,\n  cacheKey?: string,\n  outputDataType?: number,\n): void => {\n  context.compute(\n    createBinaryOpProgramInfo(\n      name,\n      cacheKey ?? '',\n      context.inputs[0],\n      context.inputs[1],\n      funcCall,\n      additionalImplementation,\n      outputDataType,\n    ),\n  );\n};\n\nexport const add = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Add', (a, b) => `${a}+${b}`);\n};\n\nexport const div = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Div', (a, b) => `${a}/${b}`);\n};\n\nexport const equal = (context: ComputeContext): void => {\n  runBinaryOp(\n    context,\n    'Equal',\n    { scalar: (a, b) => `u32(${a}==${b})`, vector: (a, b) => `vec4<u32>(${a}==${b})` },\n    undefined,\n    undefined,\n    DataType.bool,\n  );\n};\n\nexport const mul = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Mul', (a, b) => `${a}*${b}`);\n};\n\nexport const pow = (context: ComputeContext): void => {\n  const type = inputVariable('input', context.inputs[0].dataType, context.inputs[0].dims).type.value;\n  const roundStr = type === 'i32' ? 'round' : '';\n  runBinaryOp(\n    context,\n    'Pow',\n    { scalar: (a, b) => `pow_custom(${a},${b})`, vector: (a, b) => `pow_vector_custom(${a},${b})` },\n    `\n    fn pow_custom(a : ${type}, b : ${type}) -> ${type} {\n      if (b == ${type}(0.0)) {\n        return ${type}(1.0);\n      } else if (a < ${type}(0.0) && f32(b) != floor(f32(b))) {\n        return ${type}(pow(f32(a), f32(b))); // NaN\n      }\n      return select(sign(a), ${type}(1.0), round(f32(abs(b) % ${type}(2.0))) != 1.0) * ${type}(${roundStr}(pow(f32(abs(a)), f32(b))));\n    }\n    fn pow_vector_custom(a : vec4<${type}>, b : vec4<${type}>) -> vec4<${type}> {\n      // TODO: implement vectorized pow\n      return vec4<${type}>(pow_custom(a.x, b.x), pow_custom(a.y, b.y), pow_custom(a.z, b.z), pow_custom(a.w, b.w));\n    }\n      `,\n  );\n};\n\nexport const sub = (context: ComputeContext): void => {\n  runBinaryOp(context, 'Sub', (a, b) => `${a}-${b}`);\n};\n\nexport const greater = (context: ComputeContext): void => {\n  runBinaryOp(\n    context,\n    'Greater',\n    { scalar: (a, b) => `u32(${a}>${b})`, vector: (a, b) => `vec4<u32>(${a}>${b})` },\n    undefined,\n    undefined,\n    DataType.bool,\n  );\n};\n\nexport const less = (context: ComputeContext): void => {\n  runBinaryOp(\n    context,\n    'Less',\n    { scalar: (a, b) => `u32(${a}<${b})`, vector: (a, b) => `vec4<u32>(${a}<${b})` },\n    undefined,\n    undefined,\n    DataType.bool,\n  );\n};\n\nexport const greaterOrEqual = (context: ComputeContext): void => {\n  runBinaryOp(\n    context,\n    'GreaterOrEqual',\n    { scalar: (a, b) => `u32(${a}>=${b})`, vector: (a, b) => `vec4<u32>(${a}>=${b})` },\n    undefined,\n    undefined,\n    DataType.bool,\n  );\n};\n\nexport const lessOrEqual = (context: ComputeContext): void => {\n  runBinaryOp(\n    context,\n    'LessOrEqual',\n    { scalar: (a, b) => `u32(${a}<=${b})`, vector: (a, b) => `vec4<u32>(${a}<=${b})` },\n    undefined,\n    undefined,\n    DataType.bool,\n  );\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform } from '../types';\n\nimport { createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper } from './common';\n\nexport interface ConcatAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], axis: number): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('too few inputs');\n  }\n  const referenceIndex = 0;\n  const referenceInput = inputs[referenceIndex];\n  const inputType = referenceInput.dataType;\n  const inputRank = referenceInput.dims.length;\n  inputs.forEach((input, i) => {\n    if (i === referenceIndex) {\n      return;\n    }\n    // make sure types of all inputs match\n    if (input.dataType !== inputType) {\n      throw new Error('input tensors should be one type');\n    }\n    // make sure the dimensionality of all inputs are the same\n    if (input.dims.length !== inputRank) {\n      throw new Error('input tensors should have the same shape');\n    }\n    input.dims.forEach((dim, i) => {\n      if (i !== axis && dim !== referenceInput.dims[i]) {\n        throw new Error('non concat dimensions must match');\n      }\n    });\n  });\n};\n\nconst calculateInputIndexImpl = (numberOfTensors: number, sizeInConcatAxisStr: string): string => `\n  fn calculateInputIndex(index: u32) -> u32 {\n    let sizeInConcatAxis = array<u32, ${numberOfTensors}u>(${sizeInConcatAxisStr});\n    for (var i: u32 = 0u; i < ${numberOfTensors}; i += 1u ) {\n      if (index < sizeInConcatAxis[i]) {\n        return i;\n      }\n    }\n    return ${numberOfTensors}u;\n  }`;\n\nconst assignOutputData = (inputs: readonly IndicesHelper[], output: IndicesHelper) => {\n  const numberOfTensors = inputs.length;\n\n  const codeLines: string[] = [];\n  for (let i = 0; i < numberOfTensors; ++i) {\n    const returnSnippet = output.setByOffset('global_idx', inputs[i].getByIndices('indices'));\n    if (numberOfTensors === 1) {\n      codeLines.push(returnSnippet);\n    } else if (i === 0) {\n      codeLines.push(`if (inputIndex == ${i}u) { ${returnSnippet} }`);\n    } else if (i === numberOfTensors - 1) {\n      codeLines.push(`else { ${returnSnippet} }`);\n    } else {\n      codeLines.push(`else if (inputIndex == ${i}) { ${returnSnippet} }`);\n    }\n  }\n  return codeLines.join('\\n');\n};\n\nconst createConcatProgramInfo = (\n  inputs: readonly TensorView[],\n  adjustedAxis: number,\n  outputShape: number[],\n  dataType: DataType,\n): ProgramInfo => {\n  const outputSize = ShapeUtil.size(outputShape);\n\n  const sizeInConcatAxis = new Array<number>(inputs.length);\n  const inputVars = new Array<IndicesHelper>(inputs.length);\n\n  let previousSum = 0;\n  const inputDependencies: ProgramInputTensorInfoDependency[] = [];\n  const inputRanks = [];\n  const programUniforms: ProgramUniform[] = [{ type: DataType.uint32, data: outputSize }];\n  for (let i = 0; i < inputs.length; ++i) {\n    previousSum += inputs[i].dims[adjustedAxis];\n    sizeInConcatAxis[i] = previousSum;\n    inputRanks.push(inputs[i].dims.length);\n    inputVars[i] = inputVariable(`input${i}`, dataType, inputRanks[i]);\n    inputDependencies.push('rank');\n    programUniforms.push({ type: DataType.uint32, data: sizeInConcatAxis[i] });\n  }\n  for (let i = 0; i < inputs.length; ++i) {\n    programUniforms.push(...createTensorShapeVariables(inputs[i].dims));\n  }\n  programUniforms.push(...createTensorShapeVariables(outputShape));\n\n  const output = outputVariable('output', dataType, outputShape.length);\n  const indicesAxis = output.indicesGet('indices', adjustedAxis);\n  const sizeInConcatAxisStr = Array.from(Array(sizeInConcatAxis.length).keys())\n    .map((i) => `uniforms.sizeInConcatAxis${i}`)\n    .join(',');\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n\n  ${(() => {\n    shaderHelper.registerUniform('outputSize', 'u32');\n    for (let i = 0; i < inputs.length; i++) {\n      shaderHelper.registerUniform(`sizeInConcatAxis${i}`, 'u32');\n    }\n    return shaderHelper.declareVariables(...inputVars, output);\n  })()}\n\n  ${calculateInputIndexImpl(sizeInConcatAxis.length, sizeInConcatAxisStr)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n\n    var indices = ${output.offsetToIndices('global_idx')};\n\n    let inputIndex = calculateInputIndex(${indicesAxis});\n    if (inputIndex != 0u) {\n      let sizeInConcatAxis = array<u32, ${sizeInConcatAxis.length}u>(${sizeInConcatAxisStr});\n      ${indicesAxis} -= sizeInConcatAxis[inputIndex - 1u];\n    }\n\n    ${assignOutputData(inputVars, output)}\n  }`;\n\n  return {\n    name: 'Concat',\n    shaderCache: { hint: `${adjustedAxis}`, inputDependencies },\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n\nexport const concat = (context: ComputeContext, attributes: ConcatAttributes): void => {\n  const inputs = context.inputs;\n  const inputShape = inputs[0].dims;\n  const adjustedAxis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);\n  validateInputs(inputs, adjustedAxis);\n  const outputShape = inputShape.slice();\n  outputShape[adjustedAxis] = inputs.reduce(\n    (sum, input) => sum + (input.dims.length > adjustedAxis ? input.dims[adjustedAxis] : 0),\n    0,\n  );\n  // 0 length tensors are valid for concat, remove them\n  const nonEmptyInputs = inputs.filter((input) => ShapeUtil.size(input.dims) > 0);\n  context.compute(createConcatProgramInfo(nonEmptyInputs, adjustedAxis, outputShape, inputs[0].dataType), {\n    inputs: nonEmptyInputs,\n  });\n};\n\nexport const parseConcatAttributes = (attributes: Record<string, unknown>): ConcatAttributes =>\n  createAttributeWithCacheKey({ axis: attributes.axis as number });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { MAX_CLIP, MIN_CLIP } from '../../util';\nimport { ProgramUniform } from '../types';\n\nimport { UniformsArrayType } from './common';\n\nexport interface InternalActivationAttributes {\n  readonly activation: string;\n  readonly clipMin?: number;\n  readonly clipMax?: number;\n  readonly alpha?: number;\n  readonly beta?: number;\n}\n\nexport const getActivationSnippet = (\n  attributes: InternalActivationAttributes,\n  valueType: string,\n  baseType = 'f32',\n): string => {\n  switch (attributes.activation) {\n    case 'Relu':\n      return `value = max(value, ${valueType}(0.0));`;\n    case 'Sigmoid':\n      return `value = (${valueType}(1.0) / (${valueType}(1.0) + exp(-value)));`;\n    case 'Clip':\n      return `value = clamp(value, ${valueType}(${baseType}(uniforms.clip_min)), ${valueType}(${\n        baseType\n      }(uniforms.clip_max)));`;\n    case 'HardSigmoid':\n      return `value = max(${valueType}(0.0), min(${valueType}(1.0), ${baseType}(uniforms.alpha) * value + ${\n        baseType\n      }(uniforms.beta)));`;\n    case 'LeakyRelu':\n      return `value = select(${baseType}(uniforms.alpha) * value, value, value >= ${valueType}(0.0));`;\n    case 'Tanh':\n      return `let e2x = exp(-2.0 * abs(value));\n              value = sign(value) * (1.0 - e2x) / (1.0 + e2x);\n        `;\n    case '':\n      return '';\n    // TODO: adding other activations that can be fused.\n    default:\n      throw new Error(`Unsupported activation ${attributes.activation}`);\n  }\n};\n\nexport const appendActivationUniformsData = (\n  attributes: InternalActivationAttributes,\n  programUniform: ProgramUniform[],\n) => {\n  if (attributes.activation === 'Clip') {\n    programUniform.push(\n      { type: DataType.float, data: attributes.clipMax! },\n      { type: DataType.float, data: attributes.clipMin! },\n    );\n  } else if (attributes.activation === 'HardSigmoid') {\n    programUniform.push(\n      { type: DataType.float, data: attributes.alpha! },\n      { type: DataType.float, data: attributes.beta! },\n    );\n  } else if (attributes.activation === 'LeakyRelu') {\n    programUniform.push({ type: DataType.float, data: attributes.alpha! });\n  }\n};\n\nexport const appendActivationUniforms = (attributes: InternalActivationAttributes, uniforms: UniformsArrayType) => {\n  if (attributes.activation === 'Clip') {\n    uniforms.push({ name: 'clip_max', type: 'f32' }, { name: 'clip_min', type: 'f32' });\n  } else if (attributes.activation === 'HardSigmoid') {\n    uniforms.push({ name: 'alpha', type: 'f32' }, { name: 'beta', type: 'f32' });\n  } else if (attributes.activation === 'LeakyRelu') {\n    uniforms.push({ name: 'alpha', type: 'f32' });\n  }\n};\n\nexport const parseInternalActivationAttributes = (\n  attributes: Record<string, unknown> | undefined,\n): InternalActivationAttributes => {\n  const activation = (attributes?.activation as string) || '';\n  if (activation === 'HardSigmoid') {\n    const [alpha, beta] = (attributes?.activation_params as [number, number]) || [0.2, 0.5];\n    return { activation, alpha, beta };\n  } else if (activation === 'Clip') {\n    const [clipMin, clipMax] = (attributes?.activation_params as [number, number]) || [MIN_CLIP, MAX_CLIP];\n    return { activation, clipMax, clipMin };\n  } else if (activation === 'LeakyRelu') {\n    const [alpha] = (attributes?.activation_params as [number]) || [0.01];\n    return { activation, alpha };\n  }\n  return { activation };\n};\n", "/**\n * @license\n * Copyright 2021 Google LLC. All Rights Reserved.\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 */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/activation_util.ts\n//\n// modified to fit the needs of the project\n\nexport const typeSnippet = (component: number, dataType: string) => {\n  switch (component) {\n    case 1:\n      return dataType;\n    case 2:\n      return `vec2<${dataType}>`;\n    case 3:\n      return `vec3<${dataType}>`;\n    case 4:\n      return `vec4<${dataType}>`;\n    default:\n      throw new Error(`${component}-component is not supported.`);\n  }\n};\n\nexport const biasSnippet = (hasBias: boolean): string => `\n      ${hasBias ? 'value = value + getBiasByOutputCoords(coords);' : ''}\n      `;\n", "/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\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 */\n\n// sampled from [@tensorflow/tfjs] tfjs-core/src/ops/conv_util.ts\n//\n// modified to fit the needs of the project\n\nexport const utilFunctions = (strideStr: string) => `\nfn getIndexFromCoords4D(coords : vec4<i32>, shape : vec4<i32>) -> i32 {\n  return dot(coords, vec4<i32>(\n      shape.y * shape.z * shape.w, shape.z * shape.w, shape.w, 1));\n}\nfn getOutputIndexFromCoords(coords : vec4<i32>) -> i32 {\n  return dot(coords, vec4<i32>(\n    i32(${strideStr}.x), i32(${strideStr}.y), i32(${strideStr}.z), 1));\n}\n`;\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { ProgramInfo, ProgramUniform } from '../types';\n\nimport {\n  createTensorShapeVariables,\n  getElementAt,\n  getMaxComponents,\n  IndicesHelper,\n  inputVariable,\n  internalVariable,\n  outputVariable,\n  ShaderHelper,\n  tensorTypeToWsglStorageType,\n  UniformsArrayType,\n} from './common';\nimport {\n  appendActivationUniforms,\n  appendActivationUniformsData,\n  getActivationSnippet,\n  InternalActivationAttributes,\n} from './fuse-utils';\n\n// Helper that convert output batch indices to input batch indices using only the rank and\n// the shape information in uniform\nexport const convertOutputBatchIndicesToInputBatchIndices = (\n  targetIndicesName: string,\n  inputVariable: IndicesHelper,\n  inputBatchRank: number,\n  outputBatchRank: number,\n  batchIndicesName: string,\n) => {\n  // Assume outputBatchRank >= inputBatchRank, the first outputBatchRank - inputBatchRank of\n  // outputBatchRank should be ignored.\n  const extendingInputRank = outputBatchRank - inputBatchRank;\n  return `\n      ${Array.from({ length: inputBatchRank })\n        .map(\n          (_, i) => `\n      if (${getElementAt(inputVariable.shape, i, inputVariable.rank)} != 1) {\n        ${inputVariable.indicesSet(targetIndicesName, i, getElementAt(batchIndicesName, i + extendingInputRank, outputBatchRank))}\n      } else {\n        ${inputVariable.indicesSet(targetIndicesName, i, 0)}\n      }`,\n        )\n        .join('')}\n`;\n};\n\nexport const createNaiveMatmulProgramInfo = (\n  inputs: readonly TensorView[],\n  activationAttributes: InternalActivationAttributes,\n  outputShape: readonly number[],\n  reshapedOutputShape?: readonly number[],\n  isChannelsLast = false /* only used for conv2dByMatMul*/,\n  squeezeOutputShapeFunction?: (shape: readonly number[]) => number[],\n): ProgramInfo => {\n  const aShape = inputs[0].dims;\n  const bShape = inputs[1].dims;\n\n  const M = aShape[aShape.length - 2];\n  const N = bShape[bShape.length - 1];\n  const K = aShape[aShape.length - 1];\n  const components = getMaxComponents(N);\n  const aComponents = getMaxComponents(K);\n  const outputNumber = getMaxComponents(M);\n  const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n  const hasBias = inputs.length > 2;\n  const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2);\n  const batchSize = ShapeUtil.size(outerDims);\n  const outputShapeInShader = [batchSize, M, N];\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.uint32, data: M },\n    { type: DataType.uint32, data: N },\n    { type: DataType.uint32, data: K },\n  ];\n  appendActivationUniformsData(activationAttributes, programUniforms);\n  programUniforms.push(...createTensorShapeVariables(outerDims, aShape, bShape));\n  if (hasBias) {\n    programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n  }\n  programUniforms.push(...createTensorShapeVariables(outputShapeInShader));\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const batchDims = internalVariable('batch_dims', inputs[0].dataType, outerDims.length);\n    const a = inputVariable('a', inputs[0].dataType, aShape.length, aComponents);\n    const b = inputVariable('b', inputs[1].dataType, bShape.length, components);\n    const output = outputVariable('output', inputs[0].dataType, outputShapeInShader.length, components);\n    const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n    const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType);\n    const inputVariables = [a, b];\n    let processBias = '';\n    if (hasBias) {\n      const biasComponents = isChannelsLast ? components : 1;\n      inputVariables.push(inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, biasComponents));\n      processBias = `${\n        isChannelsLast ? `value += bias[col / ${biasComponents}];` : `value += ${output.type.value}(bias[row + i]);`\n      }`;\n    }\n\n    const uniforms: UniformsArrayType = [\n      { name: 'output_size', type: 'u32' },\n      { name: 'M', type: 'u32' },\n      { name: 'N', type: 'u32' },\n      { name: 'K', type: 'u32' },\n    ];\n    appendActivationUniforms(activationAttributes, uniforms);\n\n    const calcResult = (): string => {\n      let calcStr = `var a_data: ${a.type.value};`;\n      for (let i = 0; i < aComponents; i++) {\n        calcStr += `\n              let b_data${i} = b[(b_offset + (k + ${i}) * uniforms.N + col) / ${components}];`;\n      }\n      for (let i = 0; i < outputNumber; i++) {\n        calcStr += `a_data = a[(a_offset + (row + ${i}) * uniforms.K + k) / ${aComponents}];`;\n\n        for (let j = 0; j < aComponents; j++) {\n          calcStr += `\n            values[${i}] = fma(${b.type.value}(a_data${aComponents === 1 ? '' : `[${j}]`}), b_data${j}, values[${i}]);\\n`;\n        }\n      }\n      return calcStr;\n    };\n\n    return `\n  ${shaderHelper\n    .registerUniforms(uniforms)\n    .registerInternalVariables(batchDims)\n    .declareVariables(...inputVariables, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    let col = (global_idx % (uniforms.N / ${components})) * ${components};\n    var index1 = global_idx / (uniforms.N / ${components});\n    let stride1 = uniforms.M / ${outputNumber};\n    let row = (index1 % stride1) * ${outputNumber};\n    let batch = index1 / stride1;\n\n    ${outputShape.length === 2 ? '' : `let batch_indices = ${batchDims.offsetToIndices('batch')};`}\n\n    var a_indices: ${a.type.indices};\n    ${convertOutputBatchIndicesToInputBatchIndices('a_indices', a, a.rank - 2, batchDims.rank, 'batch_indices')}\n    ${a.indicesSet('a_indices', a.rank - 2, 0)}\n    ${a.indicesSet('a_indices', a.rank - 1, 0)}\n    let a_offset = ${a.indicesToOffset('a_indices')};\n\n    var b_indices: ${b.type.indices};\n    ${convertOutputBatchIndicesToInputBatchIndices('b_indices', b, b.rank - 2, batchDims.rank, 'batch_indices')}\n    ${b.indicesSet('b_indices', b.rank - 2, 0)}\n    ${b.indicesSet('b_indices', b.rank - 1, 0)}\n    let b_offset = ${b.indicesToOffset('b_indices')};\n    var values: array<${output.type.value}, ${outputNumber}>;\n    for (var k: u32 = 0u; k < uniforms.K; k = k + ${aComponents}) {\n      ${calcResult()}\n    }\n    for (var i = 0u; i < ${outputNumber}u; i++) {\n      var value = values[i];\n      ${processBias}\n      ${applyActivation}\n      let cur_indices = ${output.type.indices}(batch, row + i, col);\n      let offset = ${output.indicesToOffset('cur_indices')};\n      ${output.setByOffset(`offset / ${components}`, 'value')};\n    }\n  }\n  `;\n  };\n  return {\n    name: 'MatMulNaive',\n    shaderCache: {\n      hint: `${activationAttributes.activation};${components};${aComponents};${outputNumber};${isChannelsLast}`,\n      inputDependencies: hasBias ? ['rank', 'rank', 'rank'] : ['rank', 'rank'],\n    },\n    getRunData: () => ({\n      outputs: [\n        {\n          dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n          dataType: inputs[0].dataType,\n        },\n      ],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n", "/**\n * @license\n * Copyright 2019 Google LLC. All Rights Reserved.\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 */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/matmul_packed_webgpu.ts\n//\n// modified to fit the needs of the project\n\nimport { DataType } from '../../../../wasm-common';\nimport { TensorView } from '../../../tensor-view';\nimport { ShapeUtil } from '../../../util';\nimport { ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform } from '../../types';\nimport {\n  createTensorShapeVariables,\n  IndicesHelper,\n  inputVariable,\n  internalVariable,\n  outputVariable,\n  ShaderHelper,\n  tensorTypeToWsglStorageType,\n  UniformsArrayType,\n} from '../common';\nimport {\n  appendActivationUniforms,\n  appendActivationUniformsData,\n  getActivationSnippet,\n  InternalActivationAttributes,\n} from '../fuse-utils';\nimport { convertOutputBatchIndicesToInputBatchIndices } from '../matmul-shaders';\n\nimport { typeSnippet } from './activation_util';\n\nconst writeDataToSubAVec4Snippet = (transpose: boolean, batchDims?: IndicesHelper) => {\n  if (transpose) {\n    return `\n        mm_Asub[inputRow][inputCol] = mm_readA(batch,\n          kStart + inputRow,\n          globalRowStart / innerElementSize + inputCol${batchDims ? ', batchIndices' : ''});\n        `;\n  } else {\n    return `\n        mm_Asub[inputRow][inputCol] = mm_readA(batch,\n          globalRow + innerRow,\n          kStart / innerElementSize + inputCol${batchDims ? ', batchIndices' : ''});\n        `;\n  }\n};\n\nconst calculateResultSnippet = (transposeA: boolean, innerElementSize: number) => {\n  if (transposeA) {\n    return `\n        let ACached0 = mm_Asub[k * innerElementSize][localRow];\n        let ACached1 = mm_Asub[k * innerElementSize + 1][localRow];\n        let ACached2 = mm_Asub[k * innerElementSize + 2][localRow];\n        ${innerElementSize === 3 ? '' : 'let ACached3 = mm_Asub[k * innerElementSize + 3][localRow];'}\n        for (var i = 0; i < rowPerThread; i = i + 1) {\n          acc[i] = BCached0 * ACached0[i] + acc[i];\n          acc[i] = BCached1 * ACached1[i] + acc[i];\n          acc[i] = BCached2 * ACached2[i] + acc[i];\n          ${innerElementSize === 3 ? '' : 'acc[i] = BCached3 * ACached3[i] + acc[i];'}\n        }`;\n  } else {\n    return `\n        for (var i = 0; i < rowPerThread; i = i + 1) {\n          let ACached = mm_Asub[tileRow + i][k];\n          acc[i] = BCached0 * ACached.x + acc[i];\n          acc[i] = BCached1 * ACached.y + acc[i];\n          acc[i] = BCached2 * ACached.z + acc[i];\n          ${innerElementSize === 3 ? '' : 'acc[i] = BCached3 * ACached.w + acc[i];'}\n        }`;\n  }\n};\n\nexport const makeMatMulPackedVec4Source = (\n  workPerThread: number[],\n  workgroupSize: [number, number, number],\n  type = 'f32',\n  batchDims?: IndicesHelper,\n  transposeA = false,\n  tileInner = 32,\n  splitK = false,\n  splitedDimInner = 32,\n): string => {\n  const tileAOuter = workgroupSize[1] * workPerThread[1];\n  const tileBOuter = workgroupSize[0] * workPerThread[0];\n  const tileAWidth = transposeA ? tileAOuter : tileInner;\n  const tileAHight = transposeA ? tileInner : tileAOuter;\n  const innerElementSize = tileAWidth / workgroupSize[0];\n  const rowPerThreadB = tileInner / workgroupSize[1];\n\n  if (\n    !(\n      ((transposeA && innerElementSize === 4 && workPerThread[1] === 4) ||\n        (!transposeA && (innerElementSize === 3 || innerElementSize === 4))) &&\n      tileAWidth % workgroupSize[0] === 0 &&\n      tileInner % workgroupSize[1] === 0 &&\n      workPerThread[0] === 4\n    )\n  ) {\n    throw new Error(`If transposeA ${transposeA} is true, innerElementSize ${innerElementSize} and workPerThread[1] ${workPerThread[1]} must be 4.\n      Otherwise, innerElementSize ${innerElementSize} must be 3 or 4.\n  tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${workgroupSize[0]}. tileInner ${tileInner} must be divisible by workgroupSize[1] ${workgroupSize[1]}. colPerThread ${workPerThread[0]} must be 4.`);\n  }\n  return `\nvar<workgroup> mm_Asub: array<array<vec${innerElementSize}<${type}>, ${tileAWidth / innerElementSize}>, ${tileAHight}>;\nvar<workgroup> mm_Bsub: array<array<vec4<${type}>, ${tileBOuter / workPerThread[0]}>, ${tileInner}>;\n\nconst rowPerThread = ${workPerThread[1]};\nconst colPerThread = ${workPerThread[0]};\nconst innerElementSize = ${innerElementSize};\nconst tileInner = ${tileInner};\n\n@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]})\nfn main(@builtin(local_invocation_id) localId : vec3<u32>,\n        @builtin(global_invocation_id) globalId : vec3<u32>,\n        @builtin(workgroup_id) workgroupId : vec3<u32>) {\n  let localRow = i32(localId.y);\n  let tileRow = localRow * rowPerThread;\n  let tileCol = i32(localId.x);\n\n  let globalRow =i32(globalId.y) * rowPerThread;\n  let globalCol = i32(globalId.x);\n  let batch = ${splitK ? '0' : 'i32(globalId.z)'};\n  ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices('u32(batch)')};` : ''}\n  let globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n\n  let num_tiles = ${splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : '(uniforms.dim_inner - 1) / tileInner + 1'};\n  var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : '0'};\n\n  var acc: array<vec4<${type}>, rowPerThread>;\n\n  // Loop over shared dimension.\n  let tileRowB = localRow * ${rowPerThreadB};\n  for (var t = 0; t < num_tiles; t = t + 1) {\n      // Load one tile of A into local memory.\n      for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n          let inputRow = tileRow + innerRow;\n          let inputCol = tileCol;\n          ${writeDataToSubAVec4Snippet(transposeA, batchDims)}\n      }\n\n      // Load one tile of B into local memory.\n      for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) {\n          let inputRow = tileRowB + innerRow;\n          let inputCol = tileCol;\n          mm_Bsub[inputRow][inputCol] = mm_readB(batch, kStart + inputRow, globalCol${\n            batchDims ? ', batchIndices' : ''\n          });\n      }\n      kStart = kStart + tileInner;\n      workgroupBarrier();\n\n      // Compute acc values for a single thread.\n      for (var k = 0; k < tileInner / innerElementSize; k = k + 1) {\n          let BCached0 = mm_Bsub[k * innerElementSize][tileCol];\n          let BCached1 = mm_Bsub[k * innerElementSize + 1][tileCol];\n          let BCached2 = mm_Bsub[k * innerElementSize + 2][tileCol];\n          ${innerElementSize === 3 ? '' : 'let BCached3 = mm_Bsub[k * innerElementSize + 3][tileCol];'}\n\n          ${calculateResultSnippet(transposeA, innerElementSize)}\n      }\n\n      workgroupBarrier();\n  }\n\n  for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      mm_write(batch, globalRow + innerRow, globalCol, acc[innerRow]);\n  }\n}`;\n};\n\nconst writeDataToSubASnippet = (transpose: boolean, batchDims?: IndicesHelper) => {\n  if (transpose) {\n    return `\n            mm_Asub[inputRow][inputCol] = mm_readA(batch,\n              kStart + inputRow,\n              globalRowStart + inputCol${batchDims ? ', batchIndices' : ''});\n            `;\n  } else {\n    return `\n            mm_Asub[inputRow][inputCol] = mm_readA(batch,\n              globalRowStart + inputRow,\n              kStart + inputCol${batchDims ? ', batchIndices' : ''});\n            `;\n  }\n};\n\nconst readDataFromSubASnippet = (transposeA: boolean) =>\n  transposeA ? 'let ACached = mm_Asub[k][tileRow + innerRow];' : 'let ACached = mm_Asub[tileRow + innerRow][k];';\n\n// sequentialAccessByThreads means sequential data in memory is accessed by\n// threads, instead of a single thread (default behavior).\nexport const makeMatMulPackedSource = (\n  workPerThread: number[],\n  workgroupSize: [number, number, number],\n  type = 'f32',\n  batchDims?: IndicesHelper,\n  transposeA = false,\n  tileInner = 32,\n  splitK = false,\n  splitedDimInner = 32,\n  sequentialAccessByThreads = false,\n): string => {\n  const tileAOuter = workPerThread[1] * workgroupSize[1];\n  const tileBOuter = workPerThread[0] * workgroupSize[0];\n  const tileAWidth = transposeA ? tileAOuter : tileInner;\n  const tileAHight = transposeA ? tileInner : tileAOuter;\n\n  if (\n    !(tileAHight % workgroupSize[1] === 0 && tileAWidth % workgroupSize[0] === 0 && tileInner % workgroupSize[1] === 0)\n  ) {\n    throw new Error(\n      `tileAHight ${tileAHight} must be divisible by workgroupSize[1]${workgroupSize[1]}, tileAWidth ${tileAWidth} must be divisible by workgroupSize[0]${workgroupSize[0]}, tileInner ${tileInner} must be divisible by workgroupSize[1]${workgroupSize[1]}`,\n    );\n  }\n  const rowPerThreadA = tileAHight / workgroupSize[1];\n  const colPerThreadA = tileAWidth / workgroupSize[0];\n  const rowPerThreadB = tileInner / workgroupSize[1];\n  const matmulSnippet = sequentialAccessByThreads\n    ? `\n    let localRow = i32(localId.y);\n    let localCol = i32(localId.x);\n    let globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n    let globalColStart = i32(workgroupId.x) * ${tileBOuter};\n\n    // Loop over shared dimension.\n    for (var t = 0; t < num_tiles; t = t + 1) {\n      // Load one tile of A into local memory.\n      for (var inputRow = localRow; inputRow < ${tileAHight}; inputRow = inputRow + ${workgroupSize[1]}) {\n        for (var inputCol = localCol; inputCol < ${tileAWidth}; inputCol = inputCol + ${workgroupSize[0]}) {\n          ${writeDataToSubASnippet(transposeA, batchDims)}\n        }\n      }\n      // Load one tile of B into local memory.\n      for (var inputRow = localRow; inputRow < ${tileInner}; inputRow = inputRow + ${workgroupSize[1]}) {\n            for (var inputCol = localCol; inputCol < ${tileBOuter}; inputCol = inputCol + ${workgroupSize[0]}) {\n          mm_Bsub[inputRow][inputCol] = mm_readB(batch,\n            kStart + inputRow,\n            globalColStart + inputCol${batchDims ? ', batchIndices' : ''});\n        }\n      }\n      kStart = kStart + tileInner;\n      workgroupBarrier();\n\n      // Compute acc values for a single thread.\n      var BCached : array<${type}, colPerThread>;\n      for (var k = 0; k < tileInner; k = k + 1) {\n        for (var inner = 0; inner < colPerThread; inner = inner + 1) {\n          BCached[inner] = mm_Bsub[k][localCol + inner * ${workgroupSize[0]}];\n        }\n        for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n          let ACached = ${\n            transposeA\n              ? `mm_Asub[k][localRow + innerRow * ${workgroupSize[1]}];`\n              : `mm_Asub[localRow + innerRow * ${workgroupSize[1]}][k];`\n          }\n          for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n            acc[innerRow][innerCol] = acc[innerRow][innerCol] +\n                ACached * BCached[innerCol];\n          }\n        }\n      }\n      workgroupBarrier();\n    }\n    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      let gRow = globalRowStart + localRow + innerRow * ${workgroupSize[1]};\n      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n        let gCol = globalColStart + localCol + innerCol * ${workgroupSize[0]};\n        mm_write(batch, gRow, gCol, acc[innerRow][innerCol]);\n      }\n    }\n    `\n    : `\nlet tileRow = i32(localId.y) * rowPerThread;\nlet tileCol = i32(localId.x) * colPerThread;\n\nlet globalRow = i32(globalId.y) * rowPerThread;\nlet globalCol = i32(globalId.x) * colPerThread;\nlet globalRowStart = i32(workgroupId.y) * ${tileAOuter};\n\nlet tileRowA = i32(localId.y) * ${rowPerThreadA};\nlet tileColA = i32(localId.x) * ${colPerThreadA};\nlet tileRowB = i32(localId.y) * ${rowPerThreadB};\n// Loop over shared dimension.\nfor (var t = 0; t < num_tiles; t = t + 1) {\n  // Load one tile of A into local memory.\n  for (var innerRow = 0; innerRow < ${rowPerThreadA}; innerRow = innerRow + 1) {\n    for (var innerCol = 0; innerCol < ${colPerThreadA}; innerCol = innerCol + 1) {\n      let inputRow = tileRowA + innerRow;\n      let inputCol = tileColA + innerCol;\n      ${writeDataToSubASnippet(transposeA, batchDims)}\n    }\n  }\n\n  // Load one tile of B into local memory.\n  for (var innerRow = 0; innerRow < ${rowPerThreadB}; innerRow = innerRow + 1) {\n    for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n      let inputRow = tileRowB + innerRow;\n      let inputCol = tileCol + innerCol;\n      mm_Bsub[inputRow][inputCol] = mm_readB(batch,\n        kStart + inputRow,\n        globalCol + innerCol${batchDims ? ', batchIndices' : ''});\n    }\n  }\n  kStart = kStart + tileInner;\n  workgroupBarrier();\n\n  // Compute acc values for a single thread.\n  var BCached : array<${type}, colPerThread>;\n  for (var k = 0; k < tileInner; k = k + 1) {\n    for (var inner = 0; inner < colPerThread; inner = inner + 1) {\n      BCached[inner] = mm_Bsub[k][tileCol + inner];\n    }\n\n    for (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n      ${readDataFromSubASnippet(transposeA)}\n      for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n        acc[innerRow][innerCol] = acc[innerRow][innerCol] + ACached * BCached[innerCol];\n      }\n    }\n  }\n\n  workgroupBarrier();\n}\n\nfor (var innerRow = 0; innerRow < rowPerThread; innerRow = innerRow + 1) {\n  for (var innerCol = 0; innerCol < colPerThread; innerCol = innerCol + 1) {\n    mm_write(batch, globalRow + innerRow, globalCol + innerCol,\n        acc[innerRow][innerCol]);\n  }\n}\n`;\n\n  return `\n  var<workgroup> mm_Asub : array<array<${type}, ${tileAWidth}>, ${tileAHight}>;\n  var<workgroup> mm_Bsub : array<array<${type}, ${tileBOuter}>, ${tileInner}>;\n  const rowPerThread = ${workPerThread[1]};\n  const colPerThread = ${workPerThread[0]};\n  const tileInner = ${tileInner};\n\n@compute @workgroup_size(${workgroupSize[0]}, ${workgroupSize[1]}, ${workgroupSize[2]})\nfn main(@builtin(local_invocation_id) localId : vec3<u32>,\n        @builtin(global_invocation_id) globalId : vec3<u32>,\n        @builtin(workgroup_id) workgroupId : vec3<u32>) {\n    let batch = ${splitK ? '0' : 'i32(globalId.z)'};\n    ${batchDims ? `let batchIndices = ${batchDims.offsetToIndices('u32(batch)')};` : ''}\n    let num_tiles = ${\n      splitK ? `${Math.ceil(splitedDimInner / tileInner)}` : '(uniforms.dim_inner - 1) / tileInner + 1'\n    };\n    var kStart = ${splitK ? `i32(globalId.z) * ${splitedDimInner}` : '0'};\n\n    var acc : array<array<${type}, colPerThread>, rowPerThread>;\n    ${matmulSnippet}\n  }\n`;\n};\n\nconst matMulReadWriteFnSource = (\n  component: number,\n  hasBias: boolean,\n  applyActivation: string,\n  variables: IndicesHelper[],\n  isChannelsLast = false,\n): string => {\n  const [batchVariable, aVariable, bVariable, outputVariable] = variables;\n  const dataType = tensorTypeToWsglStorageType(variables[0].type.tensor);\n\n  const source = `\n    fn mm_readA(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${typeSnippet(\n      component,\n      dataType,\n    )} {\n      var value = ${typeSnippet(component, dataType)}(0.0);\n      let col = colIn * ${component};\n      if(row < uniforms.dim_a_outer && col < uniforms.dim_inner)\n      {\n        var aIndices: ${aVariable.type.indices};\n        ${convertOutputBatchIndicesToInputBatchIndices(\n          'aIndices',\n          aVariable,\n          aVariable.rank - 2,\n          batchVariable.rank,\n          'batchIndices',\n        )}\n        ${aVariable.indicesSet('aIndices', aVariable.rank - 2, 'u32(row)')}\n        ${aVariable.indicesSet('aIndices', aVariable.rank - 1, 'u32(colIn)')}\n        value = ${aVariable.getByIndices('aIndices')};\n      }\n      return value;\n    }\n\n    fn mm_readB(batch: i32, row: i32, colIn: i32, batchIndices: ${batchVariable.type.indices}) -> ${typeSnippet(\n      component,\n      dataType,\n    )} {\n      var value = ${typeSnippet(component, dataType)}(0.0);\n      let col = colIn * ${component};\n      if(row < uniforms.dim_inner && col < uniforms.dim_b_outer)\n      {\n        var bIndices: ${bVariable.type.indices};\n        ${convertOutputBatchIndicesToInputBatchIndices(\n          'bIndices',\n          bVariable,\n          bVariable.rank - 2,\n          batchVariable.rank,\n          'batchIndices',\n        )}\n        ${bVariable.indicesSet('bIndices', bVariable.rank - 2, 'u32(row)')}\n        ${bVariable.indicesSet('bIndices', bVariable.rank - 1, 'u32(colIn)')}\n        value = ${bVariable.getByIndices('bIndices')};\n      }\n      return value;\n    }\n\n    fn mm_write(batch: i32, row: i32, colIn: i32, valueIn: ${typeSnippet(component, dataType)}) {\n      let col = colIn * ${component};\n      if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer) {\n        var value = valueIn;\n        let coords = vec3<i32>(batch, row, colIn);\n        ${\n          hasBias\n            ? `value = value + ${isChannelsLast ? 'bias[colIn]' : `${typeSnippet(component, dataType)}(bias[row])`};`\n            : ''\n        }\n        ${applyActivation}\n        ${outputVariable.setByIndices('vec3<u32>(coords)', 'value')}\n      }\n    }\n    `;\n  return source;\n};\n\nexport const createMatmulProgramInfo = (\n  inputs: readonly TensorView[],\n  activationAttributes: InternalActivationAttributes,\n  outputShape: readonly number[],\n  reshapedOutputShape?: readonly number[],\n  isChannelsLast = false /* only used for conv2dByMatMul*/,\n  squeezeOutputShapeFunction?: (shape: readonly number[]) => number[],\n): ProgramInfo => {\n  const aShape = inputs[0].dims;\n  const bShape = inputs[1].dims;\n  const outerDimsA = aShape.slice(0, -2);\n  const outerDimsB = bShape.slice(0, -2);\n  const outerDims = reshapedOutputShape ? reshapedOutputShape.slice(0, -2) : outputShape.slice(0, -2);\n  const batchSize = ShapeUtil.size(outerDims);\n  const dimAOuter = aShape[aShape.length - 2];\n  const dimInner = aShape[aShape.length - 1];\n  const dimBOuter = bShape[bShape.length - 1];\n  const isVec4 = dimInner % 4 === 0 && dimBOuter % 4 === 0;\n\n  // TODO: fine tune size\n  const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n  const workgroupSize: [number, number, number] = [8, 8, 1];\n  const dispatch = [\n    Math.ceil(dimBOuter / workgroupSize[0] / elementsPerThread[0]),\n    Math.ceil(dimAOuter / workgroupSize[1] / elementsPerThread[1]),\n    Math.ceil(batchSize / workgroupSize[2] / elementsPerThread[2]),\n  ];\n\n  const components = isVec4 ? 4 : 1;\n  const aShapeTemp = [...outerDimsA, dimAOuter, dimInner / components];\n  const aRank = aShapeTemp.length;\n  const bShapeTemp = [...outerDimsB, dimInner, dimBOuter / components];\n  const bRank = bShapeTemp.length;\n  const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components];\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.int32, data: dimAOuter },\n    { type: DataType.int32, data: dimBOuter },\n    { type: DataType.int32, data: dimInner },\n  ];\n  appendActivationUniformsData(activationAttributes, programUniforms);\n  programUniforms.push(...createTensorShapeVariables(outerDims, aShapeTemp, bShapeTemp));\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n\n  const hasBias = inputs.length > 2;\n  if (hasBias) {\n    programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n    inputDependencies.push('rank');\n  }\n  programUniforms.push(...createTensorShapeVariables(outputShapeTemp));\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const batchRank = outerDims.length;\n    const batchDims = internalVariable('batchDims', inputs[0].dataType, batchRank, 1);\n    const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n\n    const A = inputVariable('a', inputs[0].dataType, aRank, components);\n    const B = inputVariable('b', inputs[1].dataType, bRank, components);\n    const output = outputVariable('result', inputs[0].dataType, outputShapeTemp.length, components);\n    const inputVariables = [A, B];\n    if (hasBias) {\n      const biasComponents = isChannelsLast ? components : 1;\n      inputVariables.push(inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, biasComponents));\n    }\n    const uniforms: UniformsArrayType = [\n      { name: 'dim_a_outer', type: 'i32' },\n      { name: 'dim_b_outer', type: 'i32' },\n      { name: 'dim_inner', type: 'i32' },\n    ];\n    appendActivationUniforms(activationAttributes, uniforms);\n    const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n    const applyActivation = getActivationSnippet(activationAttributes, output.type.value, baseType);\n    const declareFunctions = matMulReadWriteFnSource(\n      components,\n      hasBias,\n      applyActivation,\n      [batchDims, A, B, output],\n      isChannelsLast,\n    );\n    return `\n  ${shaderHelper\n    .registerUniforms(uniforms)\n    .registerInternalVariables(batchDims)\n    .declareVariables(...inputVariables, output)}\n  ${declareFunctions}\n  ${\n    isVec4\n      ? makeMatMulPackedVec4Source(elementsPerThread, workgroupSize, dataType, batchDims)\n      : makeMatMulPackedSource(elementsPerThread, workgroupSize, dataType, batchDims)\n  }\n                   `;\n  };\n  return {\n    name: 'MatMul',\n    shaderCache: {\n      hint: `${elementsPerThread};${activationAttributes.activation};${isVec4};${isChannelsLast}`,\n      inputDependencies,\n    },\n    getRunData: () => ({\n      outputs: [\n        {\n          dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n          dataType: inputs[0].dataType,\n        },\n      ],\n      dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n", "/**\n * @license\n * Copyright 2019 Google LLC. All Rights Reserved.\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 */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/conv2d_mm_webgpu.ts\n//\n// modified to fit the needs of the project\n\nimport { DataType } from '../../../../wasm-common';\nimport { LOG_DEBUG } from '../../../log';\nimport { TensorView } from '../../../tensor-view';\nimport { ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform } from '../../types';\nimport {\n  createTensorShapeVariables,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  tensorTypeToWsglStorageType,\n  UniformsArrayType,\n} from '../common';\nimport { ConvAttributes } from '../conv';\nimport { appendActivationUniforms, appendActivationUniformsData, getActivationSnippet } from '../fuse-utils';\n\nimport { biasSnippet, typeSnippet } from './activation_util';\nimport { utilFunctions } from './conv_util';\nimport { makeMatMulPackedSource, makeMatMulPackedVec4Source } from './matmul_packed_webgpu';\n\nconst conv2dCommonSnippet = (\n  isChannelsLast: boolean,\n  fitAOuter: boolean,\n  fitBOuter: boolean,\n  fitInner: boolean,\n  addBias = false,\n  attributes: ConvAttributes,\n  innerElementSizeX = 4,\n  innerElementSizeW = 4,\n  innerElementSize = 4,\n  dataType = 'f32',\n): string => {\n  const getXSnippet = (innerElementSize: number) => {\n    switch (innerElementSize) {\n      case 1:\n        return 'resData = x[xIndex];';\n      case 3:\n        return `resData = vec3<${dataType}>(x[xIndex], x[xIndex + 1], x[xIndex + 2]);`;\n      case 4:\n        return 'resData = x[xIndex / 4];';\n      default:\n        throw new Error(`innerElementSize ${innerElementSize} is not supported.`);\n    }\n  };\n  const getWSnippet = (innerElementSize: number) => {\n    switch (innerElementSize) {\n      case 1:\n        return 'return w[row * i32(uniforms.w_shape[3]) + colIn];';\n      case 4:\n        return 'return w[row * i32(uniforms.w_shape[3]) / 4 + colIn];';\n      default:\n        throw new Error(`innerElementSize ${innerElementSize} is not supported.`);\n    }\n  };\n  const coordASnippet = isChannelsLast\n    ? `\n    let coord = vec4<i32>(batch, xRow, xCol, xCh);\n    `\n    : `\n    let coord = vec4<i32>(batch, xCh, xRow, xCol);\n    `;\n\n  const coordResSnippet = isChannelsLast\n    ? `\n    let coords = vec4<i32>(\n      batch,\n      row / outWidth,\n      row % outWidth,\n      col);\n    `\n    : `\n    let coords = vec4<i32>(\n      batch,\n      row,\n      col / outWidth,\n      col % outWidth);\n    `;\n\n  const xHeight = isChannelsLast ? 'i32(uniforms.x_shape[1])' : 'i32(uniforms.x_shape[2])';\n  const xWidth = isChannelsLast ? 'i32(uniforms.x_shape[2])' : 'i32(uniforms.x_shape[3])';\n  const row = isChannelsLast ? 'row' : 'col';\n  const col = isChannelsLast ? 'col' : 'row';\n  const readXSnippet = `\n    let inChannels = i32(uniforms.w_shape[2]);\n    let outWidth = ${isChannelsLast ? 'i32(uniforms.result_shape[2])' : 'i32(uniforms.result_shape[3])'};\n    let outRow = ${row} / outWidth;\n    let outCol = ${row} % outWidth;\n\n    let WRow = ${col} / (i32(uniforms.w_shape[1]) * inChannels);\n    let WCol = ${col} / inChannels % i32(uniforms.w_shape[1]);\n    let xRow = outRow * uniforms.stride[0] + uniforms.dilation[0] * WRow - uniforms.pad[0];\n    let xCol = outCol * uniforms.stride[1] + uniforms.dilation[1] * WCol - uniforms.pad[1];\n    let xCh = ${col} % inChannels;\n    var resData = ${typeSnippet(innerElementSizeX, dataType)}(0.0);\n    // The bounds checking is always needed since we use it to pad zero for\n    // the 'same' padding type.\n    if (xRow >= 0 && xRow < ${xHeight} && xCol >= 0 && xCol < ${xWidth}) {\n      ${coordASnippet}\n      let xIndex = getIndexFromCoords4D(coord, vec4<i32>(uniforms.x_shape));\n      ${getXSnippet(innerElementSizeX)}\n    }\n    return resData;`;\n\n  const sampleX = isChannelsLast\n    ? fitAOuter && fitInner\n      ? `\n    let col = colIn * ${innerElementSizeX};\n    ${readXSnippet}`\n      : `\n    let col = colIn * ${innerElementSizeX};\n    if (row < uniforms.dim_a_outer && col < uniforms.dim_inner) {\n      ${readXSnippet}\n    }\n    return ${typeSnippet(innerElementSizeX, dataType)}(0.0);`\n    : fitInner && fitBOuter\n      ? `\n    let col = colIn * ${innerElementSizeX};\n    ${readXSnippet}`\n      : `\n    let col = colIn * ${innerElementSizeX};\n    if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) {\n      ${readXSnippet}\n    }\n    return ${typeSnippet(innerElementSizeX, dataType)}(0.0);`;\n\n  const sampleW = isChannelsLast\n    ? fitInner && fitBOuter\n      ? getWSnippet(innerElementSizeW)\n      : `\n    let col = colIn * ${innerElementSizeW};\n    if (row < uniforms.dim_inner && col < uniforms.dim_b_outer) {\n      ${getWSnippet(innerElementSizeW)}\n    }\n    return ${typeSnippet(innerElementSizeW, dataType)}(0.0);`\n    : `\n    let col = colIn * ${innerElementSizeW};\n    if (row < uniforms.dim_inner && col < uniforms.dim_a_outer) {\n      ${getWSnippet(innerElementSizeW)}\n    }\n    return ${typeSnippet(innerElementSizeW, dataType)}(0.0);`;\n\n  const resType = typeSnippet(innerElementSize, dataType);\n  const aType = isChannelsLast ? typeSnippet(innerElementSizeX, dataType) : typeSnippet(innerElementSizeW, dataType);\n  const bType = isChannelsLast ? typeSnippet(innerElementSizeW, dataType) : typeSnippet(innerElementSizeX, dataType);\n  const applyActivation = getActivationSnippet(attributes, resType, dataType);\n  const userCode = `\n    fn mm_readA(batch: i32, row : i32, colIn : i32) -> ${aType} {\n      ${isChannelsLast ? sampleX : sampleW}\n    }\n\n    fn mm_readB(batch: i32, row : i32, colIn : i32) -> ${bType} {\n      ${isChannelsLast ? sampleW : sampleX}\n    }\n\n    fn mm_write(batch: i32, row : i32, colIn : i32, valueIn : ${resType}) {\n      let col = colIn * ${innerElementSize};\n      if (row < uniforms.dim_a_outer && col < uniforms.dim_b_outer)\n      {\n      var value = valueIn;\n      let outWidth = ${isChannelsLast ? 'i32(uniforms.result_shape[2])' : 'i32(uniforms.result_shape[3])'};\n      ${coordResSnippet}\n      ${biasSnippet(addBias)}\n      ${applyActivation}\n      setOutputAtCoords(coords[0], coords[1], coords[2], coords[3], value);\n      }\n    }`;\n  return userCode;\n};\n\nexport const createConv2DMatMulProgramInfo = (\n  inputs: readonly TensorView[],\n  attributes: ConvAttributes,\n  outputShape: readonly number[],\n  dimAOuter: number,\n  dimBOuter: number,\n  dimInner: number,\n  hasBias: boolean,\n  sequentialAccessByThreads: boolean,\n  squeezeOutputShapeFunction?: (shape: readonly number[]) => number[],\n): ProgramInfo => {\n  const isChannelsLast = attributes.format === 'NHWC';\n  const inChannels = isChannelsLast ? inputs[0].dims[3] : inputs[0].dims[1];\n  const batchSize = outputShape[0];\n  const outWidth = isChannelsLast ? outputShape[2] : outputShape[3];\n  const outHeight = isChannelsLast ? outputShape[1] : outputShape[2];\n  const outChannels = isChannelsLast ? outputShape[3] : outputShape[1];\n  // TODO: enable vec4 for NCHW\n  const isVec4 = isChannelsLast && (inChannels % 4 === 0 || inChannels % 3 === 0) && outChannels % 4 === 0;\n\n  // TODO: fine tune size\n  const dispatchX = isChannelsLast ? outChannels : outWidth * outHeight;\n  const dispatchY = isChannelsLast ? outWidth * outHeight : outChannels;\n  const workGroupSize: [number, number, number] = [8, 8, 1];\n  const elementsPerThread = dimAOuter <= 8 ? [4, 1, 1] : [4, 4, 1];\n  const dispatch = [\n    Math.ceil(dispatchX / workGroupSize[0] / elementsPerThread[0]),\n    Math.ceil(dispatchY / workGroupSize[1] / elementsPerThread[1]),\n    Math.ceil(batchSize / workGroupSize[2] / elementsPerThread[2]),\n  ];\n\n  LOG_DEBUG('verbose', () => `[conv2d_mm_webgpu] dispatch = ${dispatch}`);\n\n  const innerElementSize = isVec4 ? (isChannelsLast && inChannels % 4 !== 0 ? 3 : 4) : 1;\n  const tileAOuter = workGroupSize[1] * elementsPerThread[1];\n  const tileBOuter = workGroupSize[0] * elementsPerThread[0];\n  const tileInner = Math.max(workGroupSize[0] * innerElementSize, workGroupSize[1]);\n  const fitAOuter = dimAOuter % tileAOuter === 0;\n  const fitBOuter = dimBOuter % tileBOuter === 0;\n  const fitInner = dimInner % tileInner === 0;\n  const elementsSize = isVec4 ? [innerElementSize, 4, 4] : [1, 1, 1];\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.int32, data: dimAOuter },\n    { type: DataType.int32, data: dimBOuter },\n    { type: DataType.int32, data: dimInner },\n    { type: DataType.int32, data: [attributes.pads[0], attributes.pads[1]] },\n    { type: DataType.int32, data: attributes.strides },\n    { type: DataType.int32, data: attributes.dilations },\n  ];\n  appendActivationUniformsData(attributes, programUniforms);\n  programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims));\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n  if (hasBias) {\n    programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n    inputDependencies.push('rank');\n  }\n  programUniforms.push(...createTensorShapeVariables(outputShape));\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const uniforms: UniformsArrayType = [\n      { name: 'dim_a_outer', type: 'i32' },\n      { name: 'dim_b_outer', type: 'i32' },\n      { name: 'dim_inner', type: 'i32' },\n      { name: 'pad', type: 'i32', length: 2 },\n      { name: 'stride', type: 'i32', length: 2 },\n      { name: 'dilation', type: 'i32', length: 2 },\n    ];\n    appendActivationUniforms(attributes, uniforms);\n\n    // TODO: support component 2, 3.\n    const components = isVec4 ? 4 : 1;\n    const t = tensorTypeToWsglStorageType(inputs[0].dataType);\n    let declareFunctions = `\n      fn setOutputAtIndex(flatIndex : i32, value : ${isVec4 ? `vec4<${t}>` : t}) {\n        result[flatIndex] = ${isVec4 ? `vec4<${t}>` : t}(value);\n      }\n      fn setOutputAtCoords(d0 : i32, d1 : i32, d2 : i32, d3 : i32, value : ${isVec4 ? `vec4<${t}>` : t}) {\n        let flatIndex = getOutputIndexFromCoords(vec4<i32>(d0, d1, d2, d3));\n        setOutputAtIndex(flatIndex ${isVec4 ? '/ 4' : ''}, value);\n      }`;\n    const x = inputVariable(\n      'x',\n      inputs[0].dataType,\n      inputs[0].dims.length,\n      innerElementSize === 3 ? 1 : innerElementSize,\n    );\n    const w = inputVariable('w', inputs[1].dataType, inputs[1].dims.length, components);\n    const inputVariables = [x, w];\n    const output = outputVariable('result', inputs[0].dataType, outputShape.length, components);\n    if (hasBias) {\n      const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, components);\n      inputVariables.push(bias);\n      declareFunctions += `\n        fn getBiasByOutputCoords(coords : vec4<i32>) -> ${isVec4 ? `vec4<${t}>` : t} {\n          return bias[coords.${isChannelsLast ? 'w' : 'y'}${isVec4 ? '/ 4' : ''}];\n        }`;\n    }\n\n    return `\n        ${utilFunctions('uniforms.result_strides')}\n        //struct Uniforms { xShape : vec4<i32>, wShape : vec4<i32>, outShape : vec4<i32>,\n        //  outShapeStrides: vec3<i32>, filterDims : vec2<i32>, pad : vec2<i32>, stride : vec2<i32>,\n        //  dilation : vec2<i32>, dimAOuter : i32, dimBOuter : i32, dimInner : i32 };\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n        ${declareFunctions}\n        ${conv2dCommonSnippet(\n          isChannelsLast,\n          fitAOuter,\n          fitBOuter,\n          fitInner,\n          hasBias,\n          attributes,\n          elementsSize[0],\n          elementsSize[1],\n          elementsSize[2],\n          t,\n        )}\n        ${\n          isVec4\n            ? makeMatMulPackedVec4Source(elementsPerThread, workGroupSize, t, undefined, !isChannelsLast, tileInner)\n            : makeMatMulPackedSource(\n                elementsPerThread,\n                workGroupSize,\n                t,\n                undefined,\n                !isChannelsLast,\n                tileInner,\n                false,\n                undefined,\n                sequentialAccessByThreads,\n              )\n        }`;\n  };\n  return {\n    name: 'Conv2DMatMul',\n    shaderCache: {\n      hint: `${attributes.cacheKey};${innerElementSize};${isVec4};${fitAOuter};${fitBOuter};${fitInner};${tileAOuter};${tileBOuter};${tileInner}`,\n      inputDependencies,\n    },\n    getRunData: () => ({\n      outputs: [\n        {\n          dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n          dataType: inputs[0].dataType,\n        },\n      ],\n      dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n", "/**\n * @license\n * Copyright 2019 Google LLC. All Rights Reserved.\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 */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/conv3d_naive_webgpu.ts\n//\n// modified to fit the needs of the project\n\nimport { DataType } from '../../../../wasm-common';\nimport { LOG_DEBUG } from '../../../log';\nimport { TensorView } from '../../../tensor-view';\nimport { ShapeUtil } from '../../../util';\nimport { ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform } from '../../types';\nimport {\n  createTensorShapeVariables,\n  getElementAt,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  tensorTypeToWsglStorageType,\n  UniformsArrayType,\n} from '../common';\nimport { ConvAttributes } from '../conv';\nimport { appendActivationUniforms, appendActivationUniformsData, getActivationSnippet } from '../fuse-utils';\n\nimport { typeSnippet } from './activation_util';\n\nconst arrayProduct = (arr: number[]) => {\n  let product = 1;\n  for (let i = 0; i < arr.length; i++) {\n    product *= arr[i];\n  }\n  return product;\n};\n\nconst parse3TupleParam = (param: number | [number, number, number]): [number, number, number] =>\n  typeof param === 'number' ? [param, param, param] : param;\n\nconst getEffectiveFilterSize = (filterSize: number, dilation: number): number => {\n  if (dilation <= 1) {\n    return filterSize;\n  }\n\n  return filterSize + (filterSize - 1) * (dilation - 1);\n};\n\nconst computeDefaultPad = (\n  inputShape: [number, number] | [number, number, number, number],\n  fieldSize: number,\n  stride: number,\n  dilation = 1,\n): number => {\n  const effectiveFieldSize = getEffectiveFilterSize(fieldSize, dilation);\n  return Math.floor((inputShape[0] * (stride - 1) - stride + effectiveFieldSize) / 2);\n};\n\nconst computeOutputShape4D = (\n  inShape: [number, number, number, number],\n  filterShape: [number, number, number],\n  outChannels: number,\n  strides: [number, number, number],\n  zeroPad?: number,\n): [number, number, number, number] => {\n  if (zeroPad == null) {\n    // eslint-disable-next-line no-param-reassign\n    zeroPad = computeDefaultPad(inShape, filterShape[0], strides[0]);\n  }\n  const outShape: [number, number, number, number] = [0, 0, 0, outChannels];\n  for (let index = 0; index < 3; index++) {\n    if (inShape[index] + 2 * zeroPad >= filterShape[index]) {\n      outShape[index] = Math.trunc((inShape[index] - filterShape[index] + 2 * zeroPad) / strides[index] + 1);\n    }\n  }\n  return outShape;\n};\n\nconst get3DPadAndOutInfo = (\n  pad: number | string | number[],\n  inDepth: number,\n  inHeight: number,\n  inWidth: number,\n  strideDepth: number,\n  strideHeight: number,\n  strideWidth: number,\n  filterDepth: number,\n  filterHeight: number,\n  filterWidth: number,\n): { padInfo: PadInfo3D; outDepth: number; outHeight: number; outWidth: number } => {\n  let padInfo: PadInfo3D;\n  let outDepth: number;\n  let outHeight: number;\n  let outWidth: number;\n\n  if (pad === 'VALID') {\n    // eslint-disable-next-line no-param-reassign\n    pad = 0;\n  }\n\n  if (typeof pad === 'number') {\n    padInfo = { top: pad, bottom: pad, left: pad, right: pad, front: pad, back: pad };\n    const outShape = computeOutputShape4D(\n      [inDepth, inHeight, inWidth, 1],\n      [filterDepth, filterHeight, filterWidth],\n      1,\n      [strideDepth, strideHeight, strideWidth],\n      pad,\n    );\n    outDepth = outShape[0];\n    outHeight = outShape[1];\n    outWidth = outShape[2];\n  } else if (Array.isArray(pad)) {\n    if (!pad.every((val, _, arr) => val === arr[0])) {\n      throw Error(`Unsupported padding parameter: ${pad}`);\n    }\n    padInfo = { top: pad[0], bottom: pad[1], left: pad[2], right: pad[3], front: pad[4], back: pad[5] };\n    const outShape = computeOutputShape4D(\n      [inDepth, inHeight, inWidth, 1],\n      [filterDepth, filterHeight, filterWidth],\n      1,\n      [strideDepth, strideHeight, strideWidth],\n      pad[0],\n    );\n    outDepth = outShape[0];\n    outHeight = outShape[1];\n    outWidth = outShape[2];\n  } else if (pad === 'SAME_UPPER') {\n    // TODO: support 'SAME_LOWER'.\n    outDepth = Math.ceil(inDepth / strideDepth);\n    outHeight = Math.ceil(inHeight / strideHeight);\n    outWidth = Math.ceil(inWidth / strideWidth);\n    const padAlongDepth = (outDepth - 1) * strideDepth + filterDepth - inDepth;\n    const padAlongHeight = (outHeight - 1) * strideHeight + filterHeight - inHeight;\n    const padAlongWidth = (outWidth - 1) * strideWidth + filterWidth - inWidth;\n    const front = Math.floor(padAlongDepth / 2);\n    const back = padAlongDepth - front;\n    const top = Math.floor(padAlongHeight / 2);\n    const bottom = padAlongHeight - top;\n    const left = Math.floor(padAlongWidth / 2);\n    const right = padAlongWidth - left;\n\n    padInfo = { top, bottom, left, right, front, back };\n  } else {\n    throw Error(`Unknown padding parameter: ${pad}`);\n  }\n  return { padInfo, outDepth, outHeight, outWidth };\n};\n\ntype PadInfo3D = {\n  top: number;\n  left: number;\n  right: number;\n  bottom: number;\n  front: number;\n  back: number;\n};\n\nexport type Conv3DInfo = {\n  batchSize: number;\n  inDepth: number;\n  inHeight: number;\n  inWidth: number;\n  inChannels: number;\n  outDepth: number;\n  outHeight: number;\n  outWidth: number;\n  outChannels: number;\n  dataFormat: 'channelsFirst' | 'channelsLast';\n  strideDepth: number;\n  strideHeight: number;\n  strideWidth: number;\n  dilationDepth: number;\n  dilationHeight: number;\n  dilationWidth: number;\n  filterDepth: number;\n  filterHeight: number;\n  filterWidth: number;\n  effectiveFilterDepth: number;\n  effectiveFilterHeight: number;\n  effectiveFilterWidth: number;\n  padInfo: PadInfo3D;\n  inShape: [number, number, number, number, number];\n  outShape: [number, number, number, number, number];\n  filterShape: [number, number, number, number, number];\n};\n\nexport const computeConv3DInfo = (\n  inShape: [number, number, number, number, number],\n  filterShape: [number, number, number, number, number],\n  strides: number | [number, number, number],\n  dilations: number | [number, number, number],\n  pad: number | string | number[],\n  depthwise = false,\n  dataFormat: 'channelsFirst' | 'channelsLast' = 'channelsLast',\n): Conv3DInfo => {\n  let batchSize, inDepth, inHeight, inWidth, inChannels;\n  if (dataFormat === 'channelsLast') {\n    [batchSize, inDepth, inHeight, inWidth, inChannels] = inShape;\n  } else if (dataFormat === 'channelsFirst') {\n    [batchSize, inChannels, inDepth, inHeight, inWidth] = inShape;\n  } else {\n    throw new Error(`Unknown dataFormat ${dataFormat}`);\n  }\n  const [filterChannels, , filterDepth, filterHeight, filterWidth] = filterShape;\n\n  const [strideDepth, strideHeight, strideWidth] = parse3TupleParam(strides);\n  const [dilationDepth, dilationHeight, dilationWidth] = parse3TupleParam(dilations);\n\n  const effectiveFilterDepth = getEffectiveFilterSize(filterDepth, dilationDepth);\n  const effectiveFilterHeight = getEffectiveFilterSize(filterHeight, dilationHeight);\n  const effectiveFilterWidth = getEffectiveFilterSize(filterWidth, dilationWidth);\n  const { padInfo, outDepth, outHeight, outWidth } = get3DPadAndOutInfo(\n    pad,\n    inDepth,\n    inHeight,\n    inWidth,\n    strideDepth,\n    strideHeight,\n    strideWidth,\n    effectiveFilterDepth,\n    effectiveFilterHeight,\n    effectiveFilterWidth,\n  );\n\n  const outChannels = depthwise ? filterChannels * inChannels : filterChannels;\n\n  let outShape: [number, number, number, number, number] = [0, 0, 0, 0, 0];\n  if (dataFormat === 'channelsFirst') {\n    outShape = [batchSize, outChannels, outDepth, outHeight, outWidth];\n  } else if (dataFormat === 'channelsLast') {\n    outShape = [batchSize, outDepth, outHeight, outWidth, outChannels];\n  }\n\n  return {\n    batchSize,\n    dataFormat,\n    inDepth,\n    inHeight,\n    inWidth,\n    inChannels,\n    outDepth,\n    outHeight,\n    outWidth,\n    outChannels,\n    padInfo,\n    strideDepth,\n    strideHeight,\n    strideWidth,\n    filterDepth,\n    filterHeight,\n    filterWidth,\n    effectiveFilterDepth,\n    effectiveFilterHeight,\n    effectiveFilterWidth,\n    dilationDepth,\n    dilationHeight,\n    dilationWidth,\n    inShape,\n    outShape,\n    filterShape,\n  };\n};\n\nexport const createConv3DNaiveProgramInfo = (\n  inputs: readonly TensorView[],\n  attributes: ConvAttributes,\n  outputShape: readonly number[],\n  filterDims: readonly number[],\n  pads: readonly number[],\n  dataFormat: string,\n): ProgramInfo => {\n  const isChannelLast = dataFormat === 'channelsLast';\n  const inChannels = isChannelLast ? inputs[0].dims[3] : inputs[0].dims[1];\n  // TODO: enable vec4.\n  const isVec4 = false;\n  const workGroupSize: [number, number, number] = [64, 1, 1];\n  const dispatchLayout = { x: outputShape.map((_, i) => i) };\n  const dispatch = [Math.ceil(arrayProduct(dispatchLayout.x.map((d) => outputShape[d])) / workGroupSize[0]), 1, 1];\n\n  LOG_DEBUG('verbose', () => `[conv3d_naive_webgpu] dispatch = ${dispatch}`);\n\n  const innerElementSize = isVec4 ? (isChannelLast && inChannels % 4 !== 0 ? 3 : 4) : 1;\n  const outputSize = ShapeUtil.size(outputShape);\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.uint32, data: filterDims },\n    { type: DataType.uint32, data: pads },\n    { type: DataType.uint32, data: attributes.strides },\n    { type: DataType.uint32, data: attributes.dilations },\n  ];\n  appendActivationUniformsData(attributes, programUniforms);\n  programUniforms.push(...createTensorShapeVariables(inputs[0].dims, inputs[1].dims));\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n  const hasBias = inputs.length === 3;\n  if (hasBias) {\n    programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n    inputDependencies.push('rank');\n  }\n  programUniforms.push(...createTensorShapeVariables(outputShape));\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const uniforms: UniformsArrayType = [\n      { name: 'output_size', type: 'u32' },\n      { name: 'filter_dims', type: 'u32', length: filterDims.length },\n      { name: 'pads', type: 'u32', length: pads.length },\n      { name: 'strides', type: 'u32', length: attributes.strides.length },\n      { name: 'dilations', type: 'u32', length: attributes.dilations.length },\n    ];\n    appendActivationUniforms(attributes, uniforms);\n    // TODO: support component 2, 3.\n    const components = isVec4 ? 4 : 1;\n    const t = tensorTypeToWsglStorageType(inputs[0].dataType);\n\n    const x = inputVariable(\n      'x',\n      inputs[0].dataType,\n      inputs[0].dims.length,\n      innerElementSize === 3 ? 1 : innerElementSize,\n    );\n    const w = inputVariable('W', inputs[1].dataType, inputs[1].dims.length, components);\n    const inputVariables = [x, w];\n    const output = outputVariable('result', inputs[0].dataType, outputShape.length, components);\n    let declareFunctions = '';\n    if (hasBias) {\n      const bias = inputVariable('bias', inputs[2].dataType, inputs[2].dims.length, components);\n      inputVariables.push(bias);\n      declareFunctions += `\n        fn getBiasByOutputCoords(coords : array<u32, 5>) -> ${isVec4 ? `vec4<${t}>` : t} {\n          return bias[${isChannelLast ? getElementAt('coords', 4, 5) : getElementAt('coords', 1, 5)}${\n            isVec4 ? '/ 4' : ''\n          }];\n        }`;\n    }\n    const resType = typeSnippet(innerElementSize, t);\n    const applyActivation = getActivationSnippet(attributes, resType, t);\n\n    return `\n            ${declareFunctions}\n            fn getX(d0 : u32, d1 : u32, d2 : u32, d3 : u32, d4 : u32) -> f32 {\n              let aIndices = array<u32, 5>(d0, d1, d2, d3, d4);\n              return ${x.getByIndices('aIndices')};\n            }\n            fn getW(d0 : u32, d1 : u32, d2 : u32, d3 : u32, d4 : u32) -> f32 {\n              let aIndices = array<u32, 5>(d0, d1, d2, d3, d4);\n              return ${w.getByIndices('aIndices')};\n            }\n          ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n          ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n              let coords = ${output.offsetToIndices('global_idx')};\n              let batch = ${getElementAt('coords', 0, x.rank)};\n              let d2 = ${\n                isChannelLast ? getElementAt('coords', x.rank - 1, x.rank) : getElementAt('coords', 1, x.rank)\n              };\n              let xFRCCorner = vec3<u32>(${\n                isChannelLast ? getElementAt('coords', 1, x.rank) : getElementAt('coords', 2, x.rank)\n              },\n              ${isChannelLast ? getElementAt('coords', 2, x.rank) : getElementAt('coords', 3, x.rank)},\n              ${\n                isChannelLast ? getElementAt('coords', 3, x.rank) : getElementAt('coords', 4, x.rank)\n              }) * uniforms.strides - uniforms.pads;\n              let xFCorner = xFRCCorner.x;\n              let xRCorner = xFRCCorner.y;\n              let xCCorner = xFRCCorner.z;\n              let xShapeY = ${\n                isChannelLast\n                  ? getElementAt('uniforms.x_shape', 1, x.rank)\n                  : getElementAt('uniforms.x_shape', 2, x.rank)\n              };\n              let xShapeZ = ${\n                isChannelLast\n                  ? getElementAt('uniforms.x_shape', 2, x.rank)\n                  : getElementAt('uniforms.x_shape', 3, x.rank)\n              };\n              let xShapeW = ${\n                isChannelLast\n                  ? getElementAt('uniforms.x_shape', 3, x.rank)\n                  : getElementAt('uniforms.x_shape', 4, x.rank)\n              };\n              let xShapeU = ${\n                isChannelLast\n                  ? getElementAt('uniforms.x_shape', 4, x.rank)\n                  : getElementAt('uniforms.x_shape', 1, x.rank)\n              };\n              let inputDepthNearestVec4 = (xShapeU / 4) * 4;\n              let inputDepthVec4Remainder = xShapeU % 4;\n\n              var value = 0.0;\n              for (var wF = 0u; wF < uniforms.filter_dims[0]; wF++) {\n                let xF = xFCorner + wF * uniforms.dilations[0];\n                if (xF < 0 || xF >= xShapeY) {\n                  continue;\n                }\n\n                for (var wR = 0u; wR < uniforms.filter_dims[1]; wR++) {\n                  let xR = xRCorner + wR * uniforms.dilations[1];\n                  if (xR < 0 || xR >= xShapeZ) {\n                    continue;\n                  }\n\n                  for (var wC = 0u; wC < uniforms.filter_dims[2]; wC++) {\n                    let xC = xCCorner + wC * uniforms.dilations[2];\n                    if (xC < 0 || xC >= xShapeW) {\n                      continue;\n                    }\n\n                    for (var d1 = 0u; d1 < inputDepthNearestVec4; d1 += 4) {\n                      ${\n                        isChannelLast\n                          ? `let xValues = vec4<f32>(\n                               getX(batch, xF, xR, xC, d1),\n                               getX(batch, xF, xR, xC, d1 + 1),\n                               getX(batch, xF, xR, xC, d1 + 2),\n                               getX(batch, xF, xR, xC, d1 + 3));\n                            `\n                          : `let xValues = vec4<f32>(\n                               getX(batch, d1, xF, xR, xC),\n                               getX(batch, d1 + 1, xF, xR, xC),\n                               getX(batch, d1 + 2, xF, xR, xC),\n                               getX(batch, d1 + 3, xF, xR, xC));\n                            `\n                      }\n                            let wValues = vec4<f32>(\n                              getW(d2, d1, wF, wR, wC),\n                              getW(d2, d1 + 1, wF, wR, wC),\n                              getW(d2, d1 + 2, wF, wR, wC),\n                              getW(d2, d1 + 3, wF, wR, wC));\n                      value += dot(xValues, wValues);\n                    }\n                    if (inputDepthVec4Remainder == 1) {\n                        ${\n                          isChannelLast\n                            ? `value += getX(batch, xF, xR, xC, inputDepthNearestVec4)\n                          * getW(d2, inputDepthNearestVec4, wF, wR, wC);`\n                            : `value += getX(batch, inputDepthNearestVec4, xF, xR, xC)\n                          * getW(d2, inputDepthNearestVec4, wF, wR, wC);`\n                        }\n                    } else if (inputDepthVec4Remainder == 2) {\n                      ${\n                        isChannelLast\n                          ? `let xValues = vec2<f32>(\n                        getX(batch, xF, xR, xC, inputDepthNearestVec4),\n                        getX(batch, xF, xR, xC, inputDepthNearestVec4 + 1));\n                      `\n                          : `let xValues = vec2<f32>(\n                        getX(batch, inputDepthNearestVec4, xF, xR, xC),\n                        getX(batch, inputDepthNearestVec4 + 1, xF, xR, xC));\n                    `\n                      }\n                    let wValues = vec2<f32>(\n                      getW(d2, inputDepthNearestVec4, wF, wR, wC),\n                      getW(d2, inputDepthNearestVec4 + 1, wF, wR, wC));\n                      value += dot(xValues, wValues);\n                    } else if (inputDepthVec4Remainder == 3) {\n                      ${\n                        isChannelLast\n                          ? `let xValues = vec3<f32>(\n                        getX(batch, xF, xR, xC, inputDepthNearestVec4),\n                        getX(batch, xF, xR, xC, inputDepthNearestVec4 + 1),\n                        getX(batch, xF, xR, xC, inputDepthNearestVec4 + 2));\n                      `\n                          : `let xValues = vec3<f32>(\n                        getX(batch, inputDepthNearestVec4, xF, xR, xC),\n                        getX(batch, inputDepthNearestVec4 + 1, xF, xR, xC),\n                        getX(batch, inputDepthNearestVec4 + 2, xF, xR, xC));\n                    `\n                      }\n                    let wValues = vec3<f32>(\n                      getW(d2, inputDepthNearestVec4, wF, wR, wC),\n                      getW(d2, inputDepthNearestVec4 + 1, wF, wR, wC),\n                      getW(d2, inputDepthNearestVec4 + 2, wF, wR, wC));\n                      value += dot(xValues, wValues);\n                    }\n                  }\n                }\n              }\n              ${hasBias ? 'value = value + getBiasByOutputCoords(coords)' : ''};\n              ${applyActivation}\n              result[global_idx] = f32(value);\n          }`;\n  };\n  return {\n    name: 'Conv3DNaive',\n    shaderCache: { hint: `${attributes.cacheKey};${isChannelLast};${innerElementSize};${hasBias}`, inputDependencies },\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n      dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform } from '../types';\n\nimport {\n  createTensorShapeVariables,\n  getMaxComponents,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  tensorTypeToWsglStorageType,\n  UniformsArrayType,\n} from './common';\nimport { ConvAttributes } from './conv';\nimport { appendActivationUniforms, appendActivationUniformsData, getActivationSnippet } from './fuse-utils';\n\n/**\n * naive grouped conv implementation, supports 1d/2d conv\n * @param squeezeOutputShapeFunction - an optional function to squeeze the output shape, only used in conv1d\n */\nexport const createGroupedConvProgramInfo = (\n  inputs: readonly TensorView[],\n  attributes: ConvAttributes,\n  outputShape: readonly number[],\n  squeezeOutputShapeFunction?: (shape: readonly number[]) => number[],\n): ProgramInfo => {\n  const hasBias = inputs.length > 2;\n  const processBias = hasBias ? 'value += b[output_channel];' : '';\n  const xShape = inputs[0].dims;\n  const wShape = inputs[1].dims;\n\n  const isChannelLast = attributes.format === 'NHWC';\n  const outputChannels = isChannelLast ? outputShape[3] : outputShape[1];\n  const outputChannelsPerGroup = outputChannels / attributes.group;\n  const components = isChannelLast && outputChannelsPerGroup >= 4 ? getMaxComponents(outputChannels) : 1;\n  const outputSize = ShapeUtil.size(outputShape) / components;\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.uint32, data: attributes.dilations },\n    { type: DataType.uint32, data: [attributes.strides[0], attributes.strides[1]] },\n    { type: DataType.uint32, data: [attributes.pads[0], attributes.pads[1]] },\n    { type: DataType.uint32, data: outputChannelsPerGroup },\n  ];\n  appendActivationUniformsData(attributes, programUniforms);\n  programUniforms.push(\n    ...createTensorShapeVariables(xShape, [wShape[0], wShape[1], wShape[2], wShape[3] / components]),\n  );\n  const inputDependencies: ProgramInputTensorInfoDependency[] = hasBias ? ['rank', 'rank', 'rank'] : ['rank', 'rank'];\n  programUniforms.push(\n    ...createTensorShapeVariables([outputShape[0], outputShape[1], outputShape[2], outputShape[3] / components]),\n  );\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length, components);\n    const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n    const applyActivation = getActivationSnippet(attributes, output.type.value, baseType);\n    const x = inputVariable('x', inputs[0].dataType, xShape.length);\n    const w = inputVariable('w', inputs[1].dataType, wShape.length, components);\n    const inputVars = [x, w];\n    if (hasBias) {\n      inputVars.push(inputVariable('b', inputs[2].dataType, inputs[2].dims, components));\n    }\n\n    const uniforms: UniformsArrayType = [\n      { name: 'output_size', type: 'u32' },\n      { name: 'dilations', type: 'u32', length: attributes.dilations.length },\n      { name: 'strides', type: 'u32', length: 2 },\n      { name: 'pads', type: 'u32', length: 2 },\n      { name: 'output_channels_per_group', type: 'u32' },\n    ];\n    appendActivationUniforms(attributes, uniforms);\n\n    const calculateResult = isChannelLast\n      ? `\n      for (var wHeight: u32 = 0u; wHeight < uniforms.w_shape[0]; wHeight++) {\n        let xHeight = xRCCorner.x + wHeight * uniforms.dilations[0];\n\n        if (xHeight < 0u || xHeight >= uniforms.x_shape[1]) {\n          continue;\n        }\n\n        for (var wWidth: u32 = 0u; wWidth < uniforms.w_shape[1]; wWidth++) {\n          let xWidth = xRCCorner.y + wWidth * uniforms.dilations[1];\n          if (xWidth < 0u || xWidth >= uniforms.x_shape[2]) {\n            continue;\n          }\n\n          for (var wInChannel: u32 = 0u; wInChannel < uniforms.w_shape[2]; wInChannel++) {\n            let input_channel = in_channel_offset + wInChannel;\n            let xVal = ${x.get('batch', 'xHeight', 'xWidth', 'input_channel')};\n            let wVal = ${w.get('wHeight', 'wWidth', 'wInChannel', 'output_channel')};\n            value += xVal * wVal;\n          }\n        }\n      }\n      `\n      : `\n      for (var wInChannel: u32 = 0u; wInChannel < uniforms.w_shape[1]; wInChannel++) {\n        let input_channel = in_channel_offset + wInChannel;\n        for (var wHeight: u32 = 0u; wHeight < uniforms.w_shape[2]; wHeight++) {\n          let xHeight = xRCCorner.x + wHeight * uniforms.dilations[0];\n\n          if (xHeight < 0u || xHeight >= uniforms.x_shape[2]) {\n            continue;\n          }\n\n          for (var wWidth: u32 = 0u; wWidth < uniforms.w_shape[3]; wWidth++) {\n            let xWidth = xRCCorner.y + wWidth * uniforms.dilations[1];\n            if (xWidth < 0u || xWidth >= uniforms.x_shape[3]) {\n              continue;\n            }\n\n            let xVal = ${x.get('batch', 'input_channel', 'xHeight', 'xWidth')};\n            let wVal = ${w.get('output_channel', 'wInChannel', 'wHeight', 'wWidth')};\n            value += xVal * wVal;\n          }\n        }\n      }\n      `;\n    return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let outputIndices = ${output.offsetToIndices('global_idx')};\n    let batch: u32 = outputIndices[0];\n    let output_channel: u32 = outputIndices[${isChannelLast ? 3 : 1}];\n    let xRCCorner: vec2<u32> = vec2<u32>(outputIndices[${isChannelLast ? 1 : 2}], outputIndices[${\n      isChannelLast ? 2 : 3\n    }]) * uniforms.strides - uniforms.pads;\n    let group_id: u32 = output_channel * ${components} / uniforms.output_channels_per_group;\n    var in_channel_offset = group_id * uniforms.w_shape[${isChannelLast ? 2 : 1}];\n\n    var value: ${output.type.value} = ${output.type.value}(0);\n    ${calculateResult}\n    ${processBias}\n    ${applyActivation}\n    ${output.setByOffset('global_idx', 'value')}\n  }`;\n  };\n  return {\n    name: 'GroupedConv',\n    shaderCache: { hint: `${attributes.cacheKey}_${components}`, inputDependencies },\n    getRunData: () => ({\n      outputs: [\n        {\n          dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n          dataType: inputs[0].dataType,\n        },\n      ],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n\nexport const createGroupedConvVectorizeProgramInfo = (\n  inputs: readonly TensorView[],\n  attributes: ConvAttributes,\n  outputShape: readonly number[],\n  squeezeOutputShapeFunction?: (shape: readonly number[]) => number[],\n): ProgramInfo => {\n  const hasBias = inputs.length > 2;\n  const components = getMaxComponents(outputShape[3]);\n  const outputNumber = getMaxComponents(outputShape[2]);\n  const outputSize = ShapeUtil.size(outputShape) / components / outputNumber;\n  const xShape = [inputs[0].dims[0], inputs[0].dims[1], inputs[0].dims[2], inputs[0].dims[3] / components];\n  const wShape = [inputs[1].dims[0], inputs[1].dims[1], inputs[1].dims[2], inputs[1].dims[3] / components];\n  const outputShapeInShader = [outputShape[0], outputShape[1], outputShape[2], outputShape[3] / components];\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.int32, data: [attributes.strides[0], attributes.strides[1]] },\n    { type: DataType.int32, data: [attributes.pads[0], attributes.pads[1]] },\n  ];\n  appendActivationUniformsData(attributes, programUniforms);\n  programUniforms.push(...createTensorShapeVariables(xShape, wShape, outputShapeInShader));\n  const xNumber = (outputNumber - 1) * attributes.strides[1] + wShape[1];\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const output = outputVariable('output', inputs[0].dataType, outputShapeInShader.length, components);\n    const baseType = tensorTypeToWsglStorageType(output.type.tensor);\n    const applyActivation = getActivationSnippet(attributes, output.type.value, baseType);\n    const x = inputVariable('x', inputs[0].dataType, xShape.length, components);\n    const w = inputVariable('w', inputs[1].dataType, wShape.length, components);\n    const inputVars = [x, w];\n    if (hasBias) {\n      inputVars.push(inputVariable('b', inputs[2].dataType, inputs[2].dims, components));\n    }\n    const processBias = hasBias ? 'value += b[output_channel];' : '';\n    const uniforms: UniformsArrayType = [\n      { name: 'output_size', type: 'u32' },\n      { name: 'strides', type: 'i32', length: 2 },\n      { name: 'pads', type: 'i32', length: 2 },\n    ];\n    appendActivationUniforms(attributes, uniforms);\n    return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVars, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    let width0 = uniforms.output_shape[3];\n    let output_channel = global_idx % width0;\n    var index1 = global_idx / width0;\n    let width1 = uniforms.output_shape[2] / ${outputNumber}u;\n    let col = (index1 % width1) * ${outputNumber}u;\n    index1 = index1 / width1;\n    let row = index1 % uniforms.output_shape[1];\n    let batch = index1 / uniforms.output_shape[1];\n\n    let x_corner = vec2<i32>(i32(row), i32(col)) * uniforms.strides - uniforms.pads;\n\n    var x_vals: array<${x.type.value}, ${xNumber}>;\n    var values: array<${output.type.value}, ${outputNumber}>;\n    let input_channel = output_channel;\n    // Use constant instead of uniform can give better performance for w's height/width.\n    for (var w_height: u32 = 0u; w_height < ${wShape[0]}; w_height++) {\n      let x_height = x_corner.x + i32(w_height);\n      if (x_height >= 0 && u32(x_height) < uniforms.x_shape[1]) {\n        for (var i = 0; i < ${xNumber}; i++) {\n          let x_width = x_corner.y + i;\n          if (x_width >= 0 && u32(x_width) < uniforms.x_shape[2]) {\n            x_vals[i] = ${x.get('batch', 'u32(x_height)', 'u32(x_width)', 'input_channel')};\n          } else {\n            x_vals[i] = ${x.type.value}(0);\n          }\n        }\n        for (var w_width: u32 = 0u; w_width < ${wShape[1]}; w_width++) {\n          let w_val = ${w.get('w_height', 'w_width', '0', 'output_channel')};\n          for (var i = 0u; i < ${outputNumber}u; i++) {\n            values[i] = fma(x_vals[i * u32(uniforms.strides[1]) + w_width], w_val, values[i]);\n          }\n        }\n      }\n    }\n\n    for (var i = 0u; i < ${outputNumber}u; i++) {\n      var value = values[i];\n      ${processBias}\n      ${applyActivation}\n      ${output.set('batch', 'row', 'col + i', 'output_channel', 'value')};\n    }\n  }`;\n  };\n\n  return {\n    name: 'GroupedConv-Vectorize',\n    shaderCache: {\n      hint: `${attributes.cacheKey};${components};${outputNumber};${xNumber};${wShape[0]};${wShape[1]}`,\n      inputDependencies: hasBias ? ['rank', 'rank', 'type'] : ['rank', 'rank'],\n    },\n    getRunData: () => ({\n      outputs: [\n        {\n          dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n          dataType: inputs[0].dataType,\n        },\n      ],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { TensorView } from '../../tensor-view';\nimport { PoolConvUtil } from '../../util';\nimport { AttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext } from '../types';\n\nimport { createConv2DMatMulProgramInfo } from './3rd-party/conv2d_mm_webgpu';\nimport { computeConv3DInfo, createConv3DNaiveProgramInfo } from './3rd-party/conv3d_naive_webgpu';\nimport { createMatmulProgramInfo } from './3rd-party/matmul_packed_webgpu';\nimport { createGroupedConvProgramInfo, createGroupedConvVectorizeProgramInfo } from './conv-grouped';\nimport { InternalActivationAttributes, parseInternalActivationAttributes } from './fuse-utils';\nimport { createNaiveMatmulProgramInfo } from './matmul-shaders';\nimport { createTransposeProgramInfo } from './transpose';\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  isChannelLast: boolean,\n): number[] => {\n  const batchSize = inputShape[0];\n  const inputSpatialShape = inputShape.slice(isChannelLast ? 1 : 2, isChannelLast ? 3 : 4);\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 outputShape = inputSpatialShapeWithPad.map((v, i) =>\n    Math.floor((v - dilatedKernelShape[i] + strides[i]) / strides[i]),\n  );\n  outputShape.splice(0, 0, batchSize);\n  outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels);\n  return outputShape;\n};\n\nexport interface ConvAttributes extends InternalActivationAttributes, AttributeWithCacheKey {\n  readonly autoPad: string;\n  readonly dilations: readonly number[];\n  readonly format: 'NHWC' | 'NCHW';\n  readonly group: number;\n  readonly kernelShape: readonly number[];\n  readonly pads: readonly number[];\n  readonly strides: readonly number[];\n  readonly wIsConst: boolean;\n}\n\n// for transposing weight tensor from [M, C/group, KH, KW] to [KH, KW, C/group, M]\nconst weightTransposeAttribute = [2, 3, 1, 0];\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: ConvAttributes): void => {\n  // Refer to the below link for all input checks\n  // https://github.com/onnx/onnx/blob/master/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  if (inputs[0].dims.length > 5) {\n    throw new Error('greater than 5D is not supported');\n  }\n\n  if (inputs[0].dims.length !== inputs[1].dims.length) {\n    throw new Error('filter does not have same dimension as input');\n  }\n\n  // FILTER_IN_CHANNEL should be equal to DATA_CHANNEL\n  const dataChannel = inputs[0].dims[attributes.format === 'NHWC' ? inputs[0].dims.length - 1 : 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\nconst getAdjustedConvAttributes = <T extends ConvAttributes>(attributes: T, inputs: readonly TensorView[]): T => {\n  const kernelShape = attributes.kernelShape.slice();\n  // if kernelShape is not well specified in the attributes, infer it from the weight tensor dims\n  if (kernelShape.length < inputs[1].dims.length - 2) {\n    kernelShape.push(...Array(inputs[1].dims.length - 2 - kernelShape.length).fill(0));\n  }\n  for (let i = 2; i < inputs[1].dims.length; ++i) {\n    if (kernelShape[i - 2] === 0) {\n      kernelShape[i - 2] = 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.format === 'NHWC',\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 });\n  return newAttributes;\n};\n\nexport const parseConvAttributes = (attributes: Record<string, unknown>): ConvAttributes => {\n  const activationAttributes = parseInternalActivationAttributes(attributes);\n  // TODO : Make this generic enough to compute default attributes for multi-dimensional conv\n  const format = attributes.format as 'NHWC' | 'NCHW';\n  const autoPad = ['NOTSET', 'VALID', 'SAME_UPPER', 'SAME_LOWER'][attributes.auto_pad as number];\n  const dilations = attributes.dilations as number[];\n  const group = attributes.group as number;\n  const kernelShape = attributes.kernel_shape as number[];\n  const pads = attributes.pads as number[];\n  const strides = attributes.strides as number[];\n  const wIsConst = (attributes.w_is_const as () => boolean)();\n\n  return {\n    autoPad,\n    format,\n    dilations,\n    group,\n    kernelShape,\n    pads,\n    strides,\n    wIsConst,\n    ...activationAttributes,\n    cacheKey: `${attributes.format};${activationAttributes.activation};`,\n  };\n};\n\nconst conv2d = (\n  context: ComputeContext,\n  inputs: readonly TensorView[],\n  attributes: ConvAttributes,\n  squeezeOutputShapeFunction?: (shape: readonly number[]) => number[],\n): void => {\n  // check attributes\n\n  // const hasPreluActivationWeights = false; /* TODO: add support for prelu activation weights */\n  const isChannelsLast = attributes.format === 'NHWC';\n  const outputShape = calculateOutputShape(\n    inputs[0].dims,\n    inputs[1].dims,\n    attributes.dilations,\n    attributes.pads,\n    attributes.strides,\n    isChannelsLast,\n  );\n  if (attributes.group !== 1) {\n    const convInputs = [inputs[0]];\n    if (isChannelsLast) {\n      const transposedWeight =\n        (context.kernelCustomData.wT as TensorView | undefined) ??\n        context.compute(createTransposeProgramInfo(inputs[1], weightTransposeAttribute), {\n          inputs: [1],\n          outputs: [attributes.wIsConst ? -2 : -1],\n        })[0];\n      if (attributes.wIsConst && !context.kernelCustomData.wT) {\n        context.kernelCustomData.wT = transposedWeight;\n      }\n      convInputs.push(transposedWeight);\n    } else {\n      convInputs.push(inputs[1]);\n    }\n    if (inputs.length === 3) {\n      convInputs.push(inputs[2]);\n    }\n    // NVIDIA GPU with ampere architecture fails with below 2 cases, but we couldn't repro them with any other\n    // GPUs. So just disable vectorize on NVIDIA ampere to ensure always correct outputs.\n    // [webgpu]Conv - conv - vectorize group - B\n    // [webgpu]Conv - conv - vectorize group - D\n    const enableGroupedConvVectorize = !context.adapterInfo.isArchitecture('ampere');\n    if (\n      enableGroupedConvVectorize &&\n      isChannelsLast &&\n      inputs[1].dims[0] === attributes.group &&\n      inputs[1].dims[1] === 1 &&\n      attributes.dilations[0] === 1 &&\n      attributes.dilations[1] === 1\n    ) {\n      context.compute(\n        createGroupedConvVectorizeProgramInfo(convInputs, attributes, outputShape, squeezeOutputShapeFunction),\n        { inputs: convInputs },\n      );\n    } else {\n      context.compute(createGroupedConvProgramInfo(convInputs, attributes, outputShape, squeezeOutputShapeFunction), {\n        inputs: convInputs,\n      });\n    }\n    return;\n  }\n\n  const hasBias = inputs.length === 3;\n  const inputHeight = inputs[0].dims[isChannelsLast ? 1 : 2];\n  const inputWidth = inputs[0].dims[isChannelsLast ? 2 : 3];\n  const inputChannels = inputs[0].dims[isChannelsLast ? 3 : 1];\n  const weightHeight = inputs[1].dims[2];\n  const weightWidth = inputs[1].dims[3];\n\n  const outHeight = outputShape[isChannelsLast ? 1 : 2];\n  const outWidth = outputShape[isChannelsLast ? 2 : 3];\n  const outChannels = outputShape[isChannelsLast ? 3 : 1];\n\n  const sameSize =\n    isChannelsLast &&\n    weightHeight === inputHeight &&\n    weightWidth === inputWidth &&\n    attributes.pads[0] === 0 &&\n    attributes.pads[1] === 0;\n  if (\n    sameSize ||\n    (weightHeight === 1 &&\n      weightWidth === 1 &&\n      attributes.dilations[0] === 1 &&\n      attributes.dilations[1] === 1 &&\n      attributes.strides[0] === 1 &&\n      attributes.strides[1] === 1 &&\n      attributes.pads[0] === 0 &&\n      attributes.pads[1] === 0)\n  ) {\n    // conv2dByMatMul\n    const batch = outputShape[0];\n    let xReshaped, wReshaped, matmulOutputShape;\n    const matmulInputs = [];\n    if (isChannelsLast) {\n      const transposedWeight =\n        (context.kernelCustomData.wT as TensorView | undefined) ??\n        context.compute(createTransposeProgramInfo(inputs[1], weightTransposeAttribute), {\n          inputs: [1],\n          outputs: [attributes.wIsConst ? -2 : -1],\n        })[0];\n      if (attributes.wIsConst && !context.kernelCustomData.wT) {\n        context.kernelCustomData.wT = transposedWeight;\n      }\n      if (sameSize) {\n        const sharedDim = inputHeight * inputWidth * inputChannels;\n        xReshaped = inputs[0].reshape([1, batch, sharedDim]);\n        wReshaped = transposedWeight.reshape([1, sharedDim, outChannels]);\n        matmulOutputShape = [1, batch, outChannels];\n      } else {\n        xReshaped = inputs[0].reshape([batch, inputHeight * inputWidth, inputChannels]);\n        wReshaped = transposedWeight.reshape([1, inputChannels, outChannels]);\n        matmulOutputShape = [batch, outHeight * outWidth, outChannels];\n      }\n      matmulInputs.push(xReshaped);\n      matmulInputs.push(wReshaped);\n    } else {\n      xReshaped = inputs[0].reshape([batch, inputChannels, inputHeight * inputWidth]);\n      wReshaped = inputs[1].reshape([1, outChannels, inputChannels]);\n      matmulOutputShape = [batch, outChannels, outHeight * outWidth];\n      matmulInputs.push(wReshaped);\n      matmulInputs.push(xReshaped);\n    }\n    if (hasBias) {\n      matmulInputs.push(inputs[2]);\n    }\n    const N = matmulOutputShape[2];\n    const K = matmulInputs[0].dims[matmulInputs[0].dims.length - 1];\n    // Tune the threshold.\n    if (N < 8 && K < 8) {\n      context.compute(\n        createNaiveMatmulProgramInfo(\n          matmulInputs,\n          attributes,\n          outputShape,\n          matmulOutputShape,\n          isChannelsLast,\n          squeezeOutputShapeFunction,\n        ),\n        { inputs: matmulInputs },\n      );\n    } else {\n      context.compute(\n        createMatmulProgramInfo(\n          matmulInputs,\n          attributes,\n          outputShape,\n          matmulOutputShape,\n          isChannelsLast,\n          squeezeOutputShapeFunction,\n        ),\n        { inputs: matmulInputs },\n      );\n    }\n    return;\n  }\n\n  // TODO: implement conv2dWithIm2Col()\n\n  const sequentialAccessByThreads = /* backend.adapterInfo.isIntel() */ true;\n\n  // STEP.1: transpose weight\n  const transposedWeight =\n    (context.kernelCustomData.wT as TensorView | undefined) ??\n    context.compute(createTransposeProgramInfo(inputs[1], weightTransposeAttribute), {\n      inputs: [1],\n      outputs: [attributes.wIsConst ? -2 : -1],\n    })[0];\n  if (attributes.wIsConst && !context.kernelCustomData.wT) {\n    context.kernelCustomData.wT = transposedWeight;\n  }\n\n  // STEP.2: prepare reshaped inputs\n  const convInputs = [inputs[0], transposedWeight];\n  if (hasBias) {\n    convInputs.push(inputs[2]);\n  }\n\n  // STEP.3: compute matmul\n  const dimAOuter = isChannelsLast ? outHeight * outWidth : outChannels;\n  const dimBOuter = isChannelsLast ? outChannels : outHeight * outWidth;\n  const dimInner = weightHeight * weightWidth * inputChannels;\n  context.compute(\n    createConv2DMatMulProgramInfo(\n      convInputs,\n      attributes,\n      outputShape,\n      dimAOuter,\n      dimBOuter,\n      dimInner,\n      hasBias,\n      sequentialAccessByThreads,\n      squeezeOutputShapeFunction,\n    ),\n    { inputs: convInputs },\n  );\n};\n\nconst conv1d = (context: ComputeContext, attributes: ConvAttributes): void => {\n  // extend the input to 2D by adding H dimension\n  const isChannelLast = attributes.format === 'NHWC';\n  const inputs = [\n    context.inputs[0].reshape(\n      isChannelLast\n        ? // [N, W, C] -> [N, H=1, W, C]\n          [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]]\n        : // [N, C, W] -> [N, C, H=1, W]\n          [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]],\n    ),\n    //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW]\n    context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]]),\n  ];\n  if (context.inputs.length === 3) {\n    inputs.push(context.inputs[2]);\n  }\n  const pads = [0, attributes.pads[0], 0, attributes.pads[1]];\n  const strides = [1].concat(attributes.strides);\n  const dilations = [1].concat(attributes.dilations);\n  const kernelShape = [1].concat(attributes.kernelShape);\n  const adjustedAttributes = getAdjustedConvAttributes(\n    { ...attributes, pads, strides, dilations, kernelShape },\n    inputs,\n  );\n  conv2d(context, inputs, adjustedAttributes, (outputShape) =>\n    isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] : [outputShape[0], outputShape[1], outputShape[3]],\n  );\n};\n\nconst conv3d = (context: ComputeContext, inputs: readonly TensorView[], attributes: ConvAttributes): void => {\n  const format = attributes.format === 'NHWC' ? 'channelsLast' : 'channelsFirst';\n  const adjustedAttributes = getAdjustedConvAttributes(attributes, inputs);\n  const pads = attributes.autoPad === 'NOTSET' ? attributes.pads : attributes.autoPad;\n  const convInfo = computeConv3DInfo(\n    inputs[0].dims as [number, number, number, number, number],\n    inputs[1].dims as [number, number, number, number, number],\n    attributes.strides as number | [number, number, number],\n    attributes.dilations as number | [number, number, number],\n    pads as string | number[],\n    false,\n    format,\n  );\n  context.compute(\n    createConv3DNaiveProgramInfo(\n      inputs,\n      adjustedAttributes,\n      convInfo.outShape,\n      [convInfo.filterDepth, convInfo.filterHeight, convInfo.filterWidth],\n      [convInfo.padInfo.front, convInfo.padInfo.top, convInfo.padInfo.left],\n      format,\n    ),\n  );\n};\n\nexport const conv = (context: ComputeContext, attributes: ConvAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  if (context.inputs[0].dims.length === 3) {\n    conv1d(context, attributes);\n  } else if (context.inputs[0].dims.length === 5) {\n    conv3d(context, context.inputs, attributes);\n  } else {\n    const adjustedAttributes = getAdjustedConvAttributes(attributes, context.inputs);\n    conv2d(context, context.inputs, adjustedAttributes);\n  }\n};\n", "/**\n * @license\n * Copyright 2021 Google LLC. All Rights Reserved.\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 */\n\n// sampled from [@tensorflow/tfjs] tfjs-backend-webgpu/src/conv_backprop_webgpu.ts\n\nimport { DataType } from '../../../../wasm-common';\nimport { LOG_DEBUG } from '../../../log';\nimport { TensorView } from '../../../tensor-view';\nimport { ShapeUtil } from '../../../util';\nimport { ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform } from '../../types';\nimport {\n  createTensorShapeVariables,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  tensorTypeToWsglStorageType,\n  UniformsArrayType,\n  getMaxComponents,\n} from '../common';\nimport { ConvTransposeAttributes } from '../conv-transpose';\n\nexport const createConvTranspose2DProgramInfo = (\n  inputs: readonly TensorView[],\n  attributes: ConvTransposeAttributes,\n  squeezeOutputShapeFunction?: (shape: readonly number[]) => number[],\n): ProgramInfo => {\n  const hasBias = inputs.length > 2;\n  const outputShape = attributes.outputShape;\n  const isChannelsLast = attributes.format === 'NHWC';\n  const group = attributes.group;\n  const wShape = inputs[1].dims;\n  const inputChannelsPerGroup = wShape[2] / group;\n  const outputChannelsPerGroup = wShape[3];\n  const aComponents = isChannelsLast ? getMaxComponents(inputChannelsPerGroup) : 1;\n  const packInputAs4 = isChannelsLast && outputChannelsPerGroup === 1 && inputChannelsPerGroup >= 4;\n  const inputChannelsPerGroupInt = packInputAs4\n    ? Math.floor(inputChannelsPerGroup / 4) * 4\n    : Math.floor(inputChannelsPerGroup / aComponents) * aComponents;\n  const inputChannelsRemainder = inputChannelsPerGroup - inputChannelsPerGroupInt;\n  const components = isChannelsLast ? getMaxComponents(outputChannelsPerGroup) : 1;\n  const bComponents = isChannelsLast ? (outputChannelsPerGroup === 1 ? aComponents : components) : 1;\n  const outputSize = ShapeUtil.size(outputShape) / components;\n  const dispatch = [Math.ceil(outputSize / 64), 1, 1];\n  LOG_DEBUG('verbose', () => `[conv2d_backprop_webgpu] dispatch = ${dispatch}`);\n\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n  const strides = [attributes.strides[0], attributes.strides[1]];\n  const filterDims = [attributes.kernelShape[isChannelsLast ? 1 : 2], attributes.kernelShape[isChannelsLast ? 2 : 3]];\n  const dilations = [attributes.dilations[0], attributes.dilations[1]];\n  const effectiveFilterDims = [\n    filterDims[0] +\n      (attributes.dilations[0] <= 1\n        ? 0\n        : (attributes.kernelShape[isChannelsLast ? 1 : 2] - 1) * (attributes.dilations[0] - 1)),\n    filterDims[1] +\n      (attributes.dilations[1] <= 1\n        ? 0\n        : (attributes.kernelShape[isChannelsLast ? 2 : 3] - 1) * (attributes.dilations[1] - 1)),\n  ];\n  const pads = [\n    effectiveFilterDims[0] - 1 - Math.floor((attributes.pads[0] + attributes.pads[2]) / 2),\n    effectiveFilterDims[1] - 1 - Math.floor((attributes.pads[1] + attributes.pads[3]) / 2),\n  ];\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.uint32, data: strides },\n    { type: DataType.uint32, data: filterDims },\n    { type: DataType.uint32, data: dilations },\n    { type: DataType.uint32, data: effectiveFilterDims },\n    { type: DataType.int32, data: pads },\n    { type: DataType.uint32, data: inputChannelsPerGroupInt },\n    { type: DataType.uint32, data: inputChannelsPerGroup },\n    { type: DataType.uint32, data: outputChannelsPerGroup },\n    ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims),\n  ];\n  if (hasBias) {\n    programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n    inputDependencies.push('rank');\n  }\n  programUniforms.push(...createTensorShapeVariables(outputShape));\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const uniforms: UniformsArrayType = [\n      { name: 'output_size', type: 'u32' },\n      { name: 'strides', type: 'u32', length: strides.length },\n      { name: 'filter_dims', type: 'u32', length: filterDims.length },\n      { name: 'dilations', type: 'u32', length: filterDims.length },\n      { name: 'effective_filter_dims', type: 'u32', length: effectiveFilterDims.length },\n      { name: 'pads', type: 'i32', length: pads.length },\n      { name: 'input_channels_per_group_int', type: 'u32' },\n      { name: 'input_channels_per_group', type: 'u32' },\n      { name: 'output_channels_per_group', type: 'u32' },\n    ];\n    const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n    const rowDim = isChannelsLast ? 1 : 2;\n    const colDim = isChannelsLast ? 2 : 3;\n    const channelDim = isChannelsLast ? 3 : 1;\n\n    const w = inputVariable('W', inputs[1].dataType, inputs[1].dims.length, bComponents);\n    const dy = inputVariable('Dy', inputs[0].dataType, inputs[0].dims.length, aComponents);\n    const inputVariables = [dy, w];\n    if (hasBias) {\n      inputVariables.push(inputVariable('bias', inputs[2].dataType, [outputShape[channelDim]].length, components));\n    }\n    const output = outputVariable('result', inputs[0].dataType, outputShape.length, components);\n\n    const calculateResult = (): string => {\n      let calcStr = '';\n      if (packInputAs4) {\n        if (aComponents === 4) {\n          calcStr += `\n        let xValue = ${dy.getByOffset('x_offset')};\n        let wValue = ${w.getByOffset('w_offset')};\n        dotProd = dotProd + dot(xValue, wValue);\n        x_offset += 1u;\n        w_offset += 1u;`;\n        } else if (aComponents === 2) {\n          calcStr += `\n          dotProd = dotProd + dot(vec4<${dataType}>(${dy.getByOffset('x_offset')}, ${dy.getByOffset('x_offset + 1u')}), vec4<${dataType}>(${w.getByOffset('w_offset')}, ${w.getByOffset('w_offset + 1u')}));\n          x_offset += 2u;\n          w_offset += 2u;`;\n        } else if (aComponents === 1) {\n          calcStr += `\n          dotProd = dotProd + dot(vec4<${dataType}>(${dy.getByOffset('x_offset')}, ${dy.getByOffset('x_offset + 1u')}, ${dy.getByOffset('x_offset + 2u')}, ${dy.getByOffset('x_offset + 3u')}), vec4<${dataType}>(${w.getByOffset('w_offset')}, ${w.getByOffset('w_offset + 1u')}, ${w.getByOffset('w_offset + 2u')}, ${w.getByOffset('w_offset + 3u')}));\n          x_offset += 4u;\n          w_offset += 4u;`;\n        }\n      } else {\n        calcStr += `\n                  let xValue = ${\n                    isChannelsLast\n                      ? dy.getByOffset(\n                          `${dy.indicesToOffset(`${dy.type.indices}(batch, idyR, idyC, inputChannel)`)} / ${aComponents}`,\n                        )\n                      : dy.get('batch', 'inputChannel', 'idyR', 'idyC')\n                  };\n        `;\n        if (aComponents === 1) {\n          calcStr += `\n          let w_offset = ${w.indicesToOffset(`${w.type.indices}(u32(wRPerm), u32(wCPerm), inputChannel, wOutChannel)`)};\n          let wValue = ${w.getByOffset(`w_offset / ${bComponents}`)};\n          dotProd = dotProd + xValue * wValue;`;\n        } else {\n          for (let c = 0; c < aComponents; c++) {\n            calcStr += `\n            let wValue${c} = ${w.getByOffset(`${w.indicesToOffset(`${w.type.indices}(u32(wRPerm), u32(wCPerm), inputChannel + ${c}, wOutChannel)`)} / ${bComponents}`)};\n            dotProd = dotProd + xValue[${c}] * wValue${c};`;\n          }\n        }\n      }\n      return calcStr;\n    };\n    const calculateRemainder = (): string => {\n      if (inputChannelsRemainder === 0) {\n        return '';\n      }\n      if (!packInputAs4) {\n        throw new Error(`packInputAs4 ${packInputAs4} is not true.`);\n      }\n      let calcStr = '';\n      if (aComponents === 1) {\n        calcStr += 'dotProd = dotProd';\n        for (let i = 0; i < inputChannelsRemainder; i++) {\n          calcStr += `\n            + ${dy.getByOffset(`x_offset + ${i}`)} * ${w.getByOffset(`w_offset + ${i}`)}`;\n        }\n        calcStr += ';';\n      } else if (aComponents === 2) {\n        if (inputChannelsRemainder !== 2) {\n          throw new Error(`Invalid inputChannelsRemainder ${inputChannelsRemainder}.`);\n        }\n        calcStr += `\n          let xValue = ${dy.getByOffset('x_offset')};\n          let wValue = ${w.getByOffset('w_offset')};\n          dotProd = dotProd + dot(xValue, wValue);`;\n      }\n      return calcStr;\n    };\n    const codeSnippet = `\n            let outputIndices = ${output.offsetToIndices(`global_idx * ${components}`)};\n            let batch = ${output.indicesGet('outputIndices', 0)};\n            let d1 = ${output.indicesGet('outputIndices', channelDim)};\n            let r = ${output.indicesGet('outputIndices', rowDim)};\n            let c = ${output.indicesGet('outputIndices', colDim)};\n            let dyCorner = vec2<i32>(i32(r), i32(c)) - uniforms.pads;\n            let dyRCorner = dyCorner.x;\n            let dyCCorner = dyCorner.y;\n            let groupId = d1 / uniforms.output_channels_per_group;\n            let wOutChannel = d1 - groupId * uniforms.output_channels_per_group;\n            // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1).\n            // ? = to be determined. : = across all values in that axis.\n            var dotProd = ${output.type.value}(0.0);\n            var wR: u32 = 0;\n            if (uniforms.dilations.x == 1) {\n              // Minimum wR >= 0 that satisfies (dyRCorner + wR) % (uniforms.strides.x) == 0\n              wR = u32(((dyRCorner + i32(uniforms.strides.x) - 1) / i32(uniforms.strides.x)) * i32(uniforms.strides.x) - dyRCorner);\n            }\n            for (; wR < uniforms.effective_filter_dims.x; wR = wR + 1) {\n              if (wR % uniforms.dilations.x != 0) {\n                continue;\n              }\n              let dyR = (${dataType}(dyRCorner) + ${dataType}(wR)) / ${dataType}(uniforms.strides[0]);\n              let wRPerm = uniforms.filter_dims.x - 1 - wR / uniforms.dilations.x;\n              if (dyR < 0.0 || dyR >= ${dataType}(uniforms.Dy_shape[${rowDim}]) || fract(dyR) > 0.0 ||\n                  wRPerm < 0) {\n                continue;\n              }\n              let idyR: u32 = u32(dyR);\n              var wC: u32 = 0;\n              if (uniforms.dilations.y == 1) {\n                // Minimum wC >= 0 that satisfies (dyCCorner + wC) % (uniforms.strides.y) == 0\n                wC = u32(((dyCCorner + i32(uniforms.strides.y) - 1) / i32(uniforms.strides.y)) * i32(uniforms.strides.y) - dyCCorner);\n              }\n              for (; wC < uniforms.effective_filter_dims.y; wC = wC + 1) {\n                if (wC % uniforms.dilations.y != 0) {\n                  continue;\n                }\n                let dyC = (${dataType}(dyCCorner) + ${dataType}(wC)) / ${dataType}(uniforms.strides.y);\n                let wCPerm = uniforms.filter_dims.y - 1 - wC / uniforms.dilations.y;\n                if (dyC < 0.0 || dyC >= ${dataType}(uniforms.Dy_shape[${colDim}]) ||\n                    fract(dyC) > 0.0 || wCPerm < 0) {\n                  continue;\n                }\n                let idyC: u32 = u32(dyC);\n                var inputChannel = groupId * uniforms.input_channels_per_group;\n                ${\n                  packInputAs4\n                    ? `\n                var x_offset = ${dy.indicesToOffset(`${dy.type.indices}(batch, idyR, idyC, inputChannel)`)} / ${aComponents};\n                var w_offset = ${w.indicesToOffset(`${w.type.indices}(wRPerm, wCPerm, inputChannel, wOutChannel)`)} / ${bComponents};\n                  `\n                    : ''\n                }\n                for (var d2: u32 = 0; d2 < uniforms.input_channels_per_group_int; d2 = d2 + ${packInputAs4 ? 4 : aComponents}) {\n                  ${calculateResult()}\n                  inputChannel = inputChannel + ${packInputAs4 ? 4 : aComponents};\n                }\n                ${calculateRemainder()}\n                wC = wC + uniforms.strides.y - 1;\n              }\n              wR = wR + uniforms.strides[0] - 1;\n            }\n            let value = dotProd${hasBias ? ` + bias[d1 / ${components}]` : ''};\n            ${output.setByOffset('global_idx', 'value')};\n          `;\n\n    return `\n    ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n      ${shaderHelper.mainStart()}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')};\n    ${codeSnippet}}`;\n  };\n\n  return {\n    name: 'ConvTranspose2D',\n    shaderCache: {\n      hint: `${attributes.cacheKey};${aComponents}${bComponents}${components}${packInputAs4}${inputChannelsRemainder}`,\n      inputDependencies,\n    },\n    getRunData: () => ({\n      dispatchGroup: { x: dispatch[0], y: dispatch[1], z: dispatch[2] },\n      outputs: [\n        {\n          dims: squeezeOutputShapeFunction ? squeezeOutputShapeFunction(outputShape) : outputShape,\n          dataType: inputs[0].dataType,\n        },\n      ],\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { TensorView } from '../../tensor-view';\nimport { ComputeContext } from '../types';\n\nimport { createConvTranspose2DProgramInfo } from './3rd-party/conv_backprop_webgpu';\nimport { ConvAttributes } from './conv';\nimport { parseInternalActivationAttributes } from './fuse-utils';\nimport { createTransposeProgramInfo } from './transpose';\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  group: number,\n  pads: number[],\n  strides: readonly number[],\n  isChannelLast: boolean,\n  outputPadding: number[],\n  outputShape: number[],\n) => {\n  const spatialRank = inputShape.length - 2;\n  const updateOutputShape = outputShape.length === 0;\n  if (outputPadding.length < spatialRank) {\n    outputPadding.push(...Array(spatialRank - outputPadding.length).fill(0));\n  }\n  const batchSize = inputShape[0];\n  const outChannels = kernelShape[isChannelLast ? 3 : 1] * group;\n  for (let i = 0, j = inputShape.length - spatialRank - (isChannelLast ? 1 : 0); i < spatialRank; ++i, ++j) {\n    const inSize = inputShape[j];\n    const outSize = updateOutputShape ? inSize * strides[i] : outputShape[i];\n    const totalPad = computeTotalPad(inSize, strides[i], pads[i], kernelShape[j], dilations[i], outSize);\n    distributePadding(totalPad, autoPad, pads, i, i + spatialRank);\n    if (updateOutputShape) {\n      outputShape.push(\n        strides[i] * (inSize - 1) +\n          outputPadding[i] +\n          (kernelShape[j] - 1) * dilations[i] +\n          1 -\n          pads[i] -\n          pads[i + spatialRank],\n      );\n    }\n  }\n  outputShape.splice(0, 0, batchSize);\n  outputShape.splice(isChannelLast ? 3 : 1, 0, outChannels);\n};\n\nexport interface ConvTransposeAttributes extends ConvAttributes {\n  readonly outputPadding: readonly number[];\n  readonly outputShape: readonly number[];\n}\n\nconst getAdjustedConvTransposeAttributes = <T extends ConvTransposeAttributes>(\n  attributes: T,\n  inputs: readonly TensorView[],\n): 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 || attributes.kernelShape.reduce((a, b) => a * b, 1) === 0) {\n    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 isChannelsLast = attributes.format === 'NHWC';\n  kernelShape.splice(0, 0, inputs[1].dims[0]);\n  kernelShape.splice(isChannelsLast ? 3 : 1, 0, inputs[1].dims[1]);\n\n  const pads = attributes.pads.slice();\n  const outputShape = attributes.outputShape.slice();\n  const outputPadding = attributes.outputPadding.slice();\n  const inputShape = inputs[0].dims;\n  let dilations = attributes.dilations.slice();\n  if (dilations.reduce((a, b) => a + b, 0) === 0) {\n    const spatialRank = inputs[0].dims.length - 2;\n    dilations = new Array(spatialRank).fill(1);\n  }\n  let strides = attributes.strides.slice();\n  if (strides.reduce((a, b) => a + b, 0) === 0) {\n    const spatialRank = inputs[0].dims.length - 2;\n    strides = new Array(spatialRank).fill(1);\n  }\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    dilations,\n    attributes.autoPad,\n    attributes.group,\n    pads,\n    strides,\n    isChannelsLast,\n    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, outputPadding, outputShape, dilations, strides });\n  return newAttributes;\n};\n\nexport const parseConvTransposeAttributes = (attributes: Record<string, unknown>): ConvTransposeAttributes => {\n  const activationAttributes = parseInternalActivationAttributes(attributes);\n  // TODO : Make this generic enough to compute default attributes for multi-dimensional conv\n  const format = attributes.format as 'NHWC' | 'NCHW';\n  const autoPad = ['NOTSET', 'VALID', 'SAME_UPPER', 'SAME_LOWER'][\n    typeof attributes.autoPad == 'undefined' ? 0 : (attributes.autoPad as number)\n  ];\n  const dilations = attributes.dilations as [number, number];\n  const group = (attributes.group as number) ?? 1; // default to 1 per ONNX spec\n  const kernelShape = attributes.kernelShape as [number, number];\n  const pads = attributes.pads as [number, number, number, number];\n  const strides = attributes.strides as [number, number];\n  const wIsConst = (attributes.wIsConst as () => boolean)();\n  const outputPadding = attributes.outputPadding as [number, number, number, number];\n  const outputShape = attributes.outputShape as [number, number];\n  return {\n    autoPad,\n    format,\n    dilations,\n    group,\n    kernelShape,\n    outputPadding,\n    outputShape,\n    pads,\n    strides,\n    wIsConst,\n    ...activationAttributes,\n    cacheKey: `${attributes.format};${activationAttributes.activation};`,\n  };\n};\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: ConvTransposeAttributes): void => {\n  // Refer to the below link for all input checks\n  // https://github.com/onnx/onnx/blob/main/docs/Operators.md#ConvTranspose\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[0].dims.length !== 3) {\n    throw new Error('currently only support 2-dimensional conv');\n  }\n\n  if (inputs[0].dims.length !== inputs[1].dims.length) {\n    throw new Error('filter does not have same dimension as input');\n  }\n\n  // FILTER_IN_CHANNEL should be equal to DATA_CHANNEL\n  const dataChannel = inputs[0].dims[attributes.format === 'NHWC' ? inputs[0].dims.length - 1 : 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  const dilationsSet = attributes.dilations.reduce((a, b) => a + b, 0) > 0;\n  // wrong dilations dimension\n  if (dilationsSet && attributes.dilations.length !== spatialRank) {\n    throw new Error(`dilations should be ${spatialRank}D`);\n  }\n\n  const stridesSet = attributes.strides.reduce((a, b) => a + b, 0) > 0;\n  // Wrong strides dimension\n  if (stridesSet && attributes.strides.length !== spatialRank) {\n    throw new Error(`strides should be ${spatialRank}D`);\n  }\n\n  // Wrong pads dimension\n  const padsSet = attributes.pads.reduce((a, b) => a + b, 0) > 0;\n  if (padsSet && 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 && attributes.outputPadding.length !== 0) {\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  const kernelShapeSet = attributes.kernelShape.reduce((a, b) => a + b, 0) > 0;\n  if (\n    kernelShapeSet &&\n    attributes.kernelShape.length !== 0 &&\n    attributes.kernelShape.length !== inputs[1].dims.length - 2\n  ) {\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\nconst convTranspose2d = (\n  context: ComputeContext,\n  inputs: readonly TensorView[],\n  attributes: ConvTransposeAttributes,\n  squeezeOutputShapeFunction?: (shape: readonly number[]) => number[],\n): void => {\n  // STEP.1: transpose weight\n  const transposedWeight =\n    (context.kernelCustomData.wT as TensorView | undefined) ??\n    context.compute(createTransposeProgramInfo(inputs[1], [2, 3, 0, 1]), {\n      inputs: [1],\n      outputs: [attributes.wIsConst ? -2 : -1],\n    })[0];\n  if (attributes.wIsConst && !context.kernelCustomData.wT) {\n    context.kernelCustomData.wT = transposedWeight;\n  }\n\n  // STEP.2: prepare reshaped inputs\n  const convTransposeInputs = [inputs[0], transposedWeight];\n  if (inputs.length === 3) {\n    convTransposeInputs.push(inputs[2]);\n  }\n  context.compute(createConvTranspose2DProgramInfo(convTransposeInputs, attributes, squeezeOutputShapeFunction), {\n    inputs: convTransposeInputs,\n  });\n};\n\nconst convTranspose1d = (context: ComputeContext, attributes: ConvTransposeAttributes): void => {\n  // extend the input to 2D by adding H dimension\n  const isChannelLast = attributes.format === 'NHWC';\n\n  const inputs = [\n    context.inputs[0].reshape(\n      isChannelLast\n        ? // [N, W, C] -> [N, H=1, W, C]\n          [context.inputs[0].dims[0], 1, context.inputs[0].dims[1], context.inputs[0].dims[2]]\n        : // [N, C, W] -> [N, C, H=1, W]\n          [context.inputs[0].dims[0], context.inputs[0].dims[1], 1, context.inputs[0].dims[2]],\n    ),\n    //[FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kW] -> [FILTER_OUT_CHANNEL, FILTER_IN_CHANNEL, kH=1, kW]\n    context.inputs[1].reshape([context.inputs[1].dims[0], context.inputs[1].dims[1], 1, context.inputs[1].dims[2]]),\n  ];\n  if (context.inputs.length === 3) {\n    inputs.push(context.inputs[2]);\n  }\n  let kernelShape = attributes.kernelShape;\n  if (kernelShape.length === 0 || kernelShape[0] === 0) {\n    kernelShape = [context.inputs[1].dims[2]];\n  }\n  let dilations = attributes.dilations;\n  if (dilations.length === 0 || dilations[0] === 0) {\n    dilations = [1];\n  }\n  let strides = attributes.strides;\n  if (strides.length === 0 || strides[0] === 0) {\n    strides = [1];\n  }\n  let pads = attributes.pads;\n  if (pads.length === 0) {\n    pads = [0, 0];\n  }\n  pads = [0, pads[0], 0, pads[1]];\n  strides = [1].concat(strides);\n  dilations = [1].concat(dilations);\n  kernelShape = [1].concat(kernelShape);\n  let outputPadding = attributes.outputPadding;\n  outputPadding = [0].concat(outputPadding);\n  const adjustedAttributes = getAdjustedConvTransposeAttributes(\n    { ...attributes, pads, strides, dilations, kernelShape, outputPadding },\n    inputs,\n  );\n\n  convTranspose2d(context, inputs, adjustedAttributes, (outputShape) =>\n    isChannelLast ? [outputShape[0], outputShape[2], outputShape[3]] : [outputShape[0], outputShape[1], outputShape[3]],\n  );\n};\n\nexport const convTranspose = (context: ComputeContext, attributes: ConvTransposeAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  if (context.inputs[0].dims.length === 3) {\n    convTranspose1d(context, attributes);\n  } else {\n    const adjustedAttributes = getAdjustedConvTransposeAttributes(attributes, context.inputs);\n    convTranspose2d(context, context.inputs, adjustedAttributes);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo } from '../types';\n\nimport { createTensorShapeVariables, getElementAt, inputVariable, outputVariable, ShaderHelper } from './common';\n\nexport interface CumSumAttributes extends AttributeWithCacheKey {\n  readonly exclusive: boolean;\n  readonly reverse: boolean;\n}\nconst createCumsumProgramInfo = (\n  inputType: number,\n  inputShape: readonly number[],\n  axisInput: TensorView,\n  attributes: CumSumAttributes,\n): ProgramInfo => {\n  const outputSize = ShapeUtil.size(inputShape); // outputShape is same as inputShape.\n  const rank = inputShape.length; // input/output rank\n  const input = inputVariable('input', inputType, rank);\n  const output = outputVariable('output', inputType, rank);\n  const axisValue =\n    axisInput.dataType === DataType.int32 ? axisInput.getInt32Array()[0] : Number(axisInput.getBigInt64Array()[0]);\n  const axis = ShapeUtil.normalizeAxis(axisValue, rank);\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const index = ` i32(${input.indicesGet('inputIndices', 'uniforms.axis')}) `;\n    const max = getElementAt('uniforms.input_shape', 'uniforms.axis', rank);\n    const lowerLimit = attributes.reverse ? index + (attributes.exclusive ? ' + 1' : '') : '0';\n    const upperLimit = attributes.reverse ? max : index + (attributes.exclusive ? '' : ' + 1');\n    return `\n                ${shaderHelper\n                  .registerUniform('outputSize', 'u32')\n                  .registerUniform('axis', 'u32')\n                  .declareVariables(input, output)}\n                ${shaderHelper.mainStart()}\n                  ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n                  var inputIndices = ${output.offsetToIndices('global_idx')};\n                  var sum = ${output.type.value}(0);\n                  let first : i32 = ${lowerLimit};\n                  let last : i32 = ${upperLimit};\n                  for (var i : i32 = first; i < last; i++) {\n                    ${input.indicesSet('inputIndices', 'uniforms.axis', 'u32(i)')};\n                    sum = sum + ${input.getByIndices('inputIndices')};\n                  }\n                  ${output.setByOffset('global_idx', 'sum')};\n                }`;\n  };\n  return {\n    name: 'CumSum',\n    shaderCache: { hint: attributes.cacheKey, inputDependencies: ['rank'] },\n    getRunData: () => ({\n      outputs: [{ dims: inputShape, dataType: inputType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms: [\n        { type: DataType.uint32, data: outputSize },\n        { type: DataType.uint32, data: axis },\n        ...createTensorShapeVariables(inputShape, inputShape),\n      ],\n    }),\n    getShaderSource,\n  };\n};\n\nexport const cumsum = (context: ComputeContext, attributes: CumSumAttributes): void => {\n  const inputShape = context.inputs[0].dims;\n  const inputType = context.inputs[0].dataType;\n  const axis = context.inputs[1];\n  context.compute(createCumsumProgramInfo(inputType, inputShape, axis, attributes), { inputs: [0] });\n};\n\nexport const parseCumSumAttributes = (attributes: Record<string, unknown>): CumSumAttributes => {\n  const exclusive = (attributes.exclusive as number) === 1;\n  const reverse = (attributes.reverse as number) === 1;\n  return createAttributeWithCacheKey({ exclusive, reverse });\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo } from '../types';\n\nimport { createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper } from './common';\n\nexport interface FormatAttributes {\n  readonly format: 'NHWC' | 'NCHW';\n}\n\nexport interface DepthToSpaceAttributes extends FormatAttributes, AttributeWithCacheKey {\n  readonly blocksize: number;\n  readonly mode: string;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('DepthToSpace requires 1 input.');\n  }\n  if (inputs[0].dims.length !== 4) {\n    throw new Error('DepthToSpace requires 4D input.');\n  }\n};\n\nconst permFunctionBody = (perm: number[], rank: number, input: IndicesHelper, output: IndicesHelper): string => {\n  const reverseFunc = [];\n  reverseFunc.push(`fn perm(i: ${output.type.indices}) -> ${input.type.indices} {\n    var a: ${input.type.indices};`);\n  for (let i = 0; i < rank; ++i) {\n    reverseFunc.push(input.indicesSet('a', perm[i], `i[${i}]`));\n  }\n  reverseFunc.push('return a;}');\n  return reverseFunc.join('\\n');\n};\n\nconst createDepthToSpaceProgramInfo = (inputTensor: TensorView, attributes: DepthToSpaceAttributes): ProgramInfo => {\n  let n: number, h: number, w: number, c: number;\n  let shape: number[];\n  let perm: number[];\n  const isChannelLast = attributes.format === 'NHWC';\n  const blocksize = attributes.blocksize;\n  const isDCRmode = attributes.mode === 'DCR';\n  if (isChannelLast) {\n    [n, h, w, c] = inputTensor.dims;\n    shape = isDCRmode\n      ? [n, h, w, blocksize, blocksize, c / blocksize ** 2]\n      : [n, h, w, c / blocksize ** 2, blocksize, blocksize];\n    perm = isDCRmode ? [0, 1, 3, 2, 4, 5] : [0, 1, 4, 2, 5, 3];\n  } else {\n    [n, h, w, c] = [inputTensor.dims[0], inputTensor.dims[2], inputTensor.dims[3], inputTensor.dims[1]];\n    shape = isDCRmode\n      ? [n, blocksize, blocksize, c / blocksize ** 2, h, w]\n      : [n, c / blocksize ** 2, blocksize, blocksize, h, w];\n    perm = isDCRmode ? [0, 3, 4, 1, 5, 2] : [0, 1, 4, 2, 5, 3];\n  }\n  const reshapedInputTensor = inputTensor.reshape(shape);\n  const reshapedInputRank = reshapedInputTensor.dims.length;\n  const inputDataType = inputTensor.dataType;\n\n  const reshapedInput = inputVariable('a', inputDataType, reshapedInputRank);\n  const permedOutput = outputVariable('output', inputDataType, reshapedInputRank);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(reshapedInput, permedOutput)}\n\n  ${permFunctionBody(perm, reshapedInputRank, reshapedInput, permedOutput)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let indices = ${permedOutput.offsetToIndices('global_idx')};\n    let aIndices = perm(indices);\n\n    ${permedOutput.setByOffset('global_idx', reshapedInput.getByIndices('aIndices'))}\n  }`;\n\n  return {\n    name: 'DepthToSpace',\n    shaderCache: {\n      hint: `${inputTensor.dims};${attributes.blocksize};${attributes.mode}`,\n      inputDependencies: ['rank'],\n    },\n    getRunData: (inputs) => {\n      const outputShape = isChannelLast\n        ? [n, h * blocksize, w * blocksize, c / blocksize ** 2]\n        : [n, c / blocksize ** 2, h * blocksize, w * blocksize];\n      const outputSize = ShapeUtil.size(outputShape);\n      const shapeBeforePerm = reshapedInputTensor.dims;\n      const shapeAfterPerm = ShapeUtil.sortBasedOnPerm(shapeBeforePerm, perm);\n      return {\n        outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n        dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n        programUniforms: [\n          { type: DataType.uint32, data: outputSize },\n          ...createTensorShapeVariables(shapeBeforePerm, shapeAfterPerm),\n        ],\n      };\n    },\n    getShaderSource,\n  };\n};\n\nexport const depthToSpace = (context: ComputeContext, attributes: DepthToSpaceAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createDepthToSpaceProgramInfo(context.inputs[0], attributes));\n};\n\nexport const parseDepthToSpaceAttributes = (attributes: Record<string, unknown>): DepthToSpaceAttributes =>\n  createAttributeWithCacheKey({\n    blocksize: attributes.blocksize as number,\n    mode: attributes.mode as string,\n    format: attributes.format as 'NHWC' | 'NCHW',\n  });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramUniform } from '../types';\n\nimport { createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper } from './common';\n\nexport interface EinsumAttributes extends AttributeWithCacheKey {\n  readonly equation: string;\n}\n// The equation attribute value is a string which consists of left hand side (LHS) and optionally right hand side (RHS)\n// separated by '->'. Ex. \"ij,jk -> ik\" expresses matrix multiplication\n//     \"ij->ji\" expresses matrix transpose\n//      \"ii->i\" diagonal elements of a square matrix\n// LHS consists of a sequence of terms separated by commas. Each term corresponds to an input variable.\n// Each symbol corresponds to a dimension in the input variable. The symbol can be either a letter, 'a' to 'z' or 'A' to\n// 'Z' or '...' to represent arbitrary dimensions.\n\nconst symbolPattern = '[a-zA-Z]|\\\\.\\\\.\\\\.'; // The pattern each symbol in each term in the symbolic equation should match\nconst termPattern = '(' + symbolPattern + ')+'; // The pattern each term in the symbolic equation should match\nconst termPatternOnly = '^' + termPattern + '$'; // The patterns only matches a term begin to end.\nconst lhsPattern = '(' + termPattern + ',)*' + termPattern; // The pattern the LHS should match\nconst lhsPatternOnly = '^' + lhsPattern + '$'; // The patterns only matches a LHS begin to end.\n\ninterface SymbolInfo {\n  count: number; // Symbol corresponding to a dimension of an input\n  inputIndices: number[]; // Number of input variables the symbol corresponds to\n  dimValue: number; // Number of dimensions the symbol corresponds to\n}\n\nclass EinsumTerm {\n  constructor(inputIndex = -1) {\n    this.symbolToIndices = new Map<string, number[]>();\n    this.inputIndex = inputIndex;\n  }\n\n  // Add a symbol to the term\n  addSymbol(symbol: string, index: number) {\n    let value = this.symbolToIndices.get(symbol);\n    if (value === undefined) {\n      value = [index];\n    } else {\n      value.push(index);\n    }\n    this.symbolToIndices.set(symbol, value);\n  }\n\n  symbolToIndices: Map<string, number[]>; // Map from symbol to dimensions of the input corresponding to the term\n  inputIndex: number; // -1 for output and 0, 1, 2, ... for inputs\n}\n\nclass EinsumEquation {\n  constructor(\n    inputs: readonly TensorView[],\n    public readonly equation: string,\n  ) {\n    this.hasEllipsis = false;\n    this.symbolToInfo = new Map<string, SymbolInfo>();\n    this.lhs = new Array<EinsumTerm>();\n    this.outputDims = [];\n    // As rhs needs to be updated allow using let instead of const for both lhs and rhs.\n    // eslint-disable-next-line prefer-const\n    let [lhs, rhs] = equation.includes('->') ? equation.split('->', 2) : [equation, ''];\n    if (!lhs.match(RegExp(lhsPatternOnly))) {\n      throw new Error('Invalid LHS term');\n    }\n    const inputTerms = lhs.split(',');\n    inputTerms.forEach((inputTerm, index) => {\n      const dims = inputs[index].dims.slice();\n      if (!inputTerm.match(RegExp(termPatternOnly))) {\n        throw new Error('Invalid LHS term');\n      }\n      const einsumTerm = this.processTerm(inputTerm, true, dims, index);\n      this.lhs.push(einsumTerm);\n    });\n\n    // Initialize the RHS if not specified\n    if (rhs === '') {\n      // Construct RHS from LHS terms/symbols\n      rhs += [...this.symbolToInfo.entries()]\n        .filter(([sym, info]) => info.count === 1 || sym === '...')\n        .map(([sym]) => sym)\n        .join('');\n    } else {\n      if (!rhs.match(RegExp(termPattern))) {\n        throw new Error('Invalid RHS');\n      }\n    }\n\n    // Compute output dims\n    const rhsSymbols = rhs.match(RegExp(symbolPattern, 'g'));\n    rhsSymbols?.forEach((symbol) => {\n      if (symbol === '...') {\n        this.outputDims = this.outputDims.concat(this.ellipsisDims);\n      } else {\n        const info = this.symbolToInfo.get(symbol);\n        if (info === undefined) {\n          throw new Error('Invalid RHS symbol');\n        }\n        this.outputDims.push(info.dimValue);\n      }\n    });\n    this.rhs = this.processTerm(rhs, false, this.outputDims);\n  } // End of EinsumEqation constructor\n\n  // Add a symbol to the equation\n  addSymbol(symbol: string, dimValue: number, inputIndex: number) {\n    let info = this.symbolToInfo.get(symbol);\n    if (info !== undefined) {\n      if (info.dimValue !== dimValue && info.count !== 1) {\n        throw new Error('Dimension mismatch');\n      } else {\n        info.count++;\n        info.inputIndices.push(inputIndex);\n      }\n    } else {\n      info = { count: 1, dimValue, inputIndices: [inputIndex] };\n    }\n    this.symbolToInfo.set(symbol, info);\n  }\n\n  // Process one input/output term\n  processTerm(term: string, isInput: boolean, dims: readonly number[], index = -1): EinsumTerm {\n    const rank = dims.length;\n    let ellipsis = false;\n    let ellipsisDims = [];\n    let nextDim = 0;\n    // For output empty string is allowed because the output may be reduced to a scalar value\n    if (!term.match(RegExp(termPatternOnly)) && !isInput && term !== '') {\n      throw new Error('Invalid LHS term');\n    }\n    const indexSymbols = term.match(RegExp(symbolPattern, 'g'));\n    const einsumTerm = new EinsumTerm(index);\n    // symbol can be either a lettre, 'a' to 'z' or 'A' to 'Z', or '...'\n    indexSymbols?.forEach((symbol: string, i: number) => {\n      if (symbol === '...') {\n        if (ellipsis) {\n          throw new Error('Only one ellipsis is allowed per input term');\n        }\n        ellipsis = true;\n        const ellipsisDimLength = rank - indexSymbols.length + 1;\n        if (ellipsisDimLength < 0) {\n          throw new Error('Ellipsis out of bounds');\n        }\n        ellipsisDims = dims.slice(nextDim, nextDim + ellipsisDimLength);\n        if (this.hasEllipsis) {\n          if (\n            this.ellipsisDims.length !== ellipsisDims.length ||\n            this.ellipsisDims.toString() !== ellipsisDims.toString()\n          ) {\n            throw new Error('Ellipsis dimensions mismatch');\n          }\n        } else if (isInput) {\n          this.hasEllipsis = true;\n          this.ellipsisDims = ellipsisDims;\n        } else {\n          throw new Error('Ellipsis must be specified in the LHS');\n        }\n        // Add '0', '1', '2', '3', '4', etc to represent ellipsis dimensions to avoid special handling\n        for (let j = 0; j < ellipsisDims.length; j++) {\n          const symbol = String.fromCharCode('0'.charCodeAt(0) + j);\n          einsumTerm.addSymbol(symbol, i + j);\n          this.addSymbol(symbol, dims[nextDim++], index);\n        }\n      } else {\n        einsumTerm.addSymbol(symbol, i + (this.hasEllipsis ? this.ellipsisDims.length - 1 : 0));\n        this.addSymbol(symbol, dims[nextDim++], index);\n      }\n    });\n    return einsumTerm;\n  }\n\n  symbolToInfo: Map<string, SymbolInfo>; // All symbols in the equation\n  hasEllipsis: boolean; // The equation has ellipsis or not\n  ellipsisDims: number[]; // The dimensions of the equation ellipsis corresponds to.\n  lhs: EinsumTerm[]; // Terms on the left-hand side of the equation\n  rhs: EinsumTerm; // Term on the right-hand side of the equation\n  outputDims: number[]; // Output dimensions of the equation\n} // End of class EinsumEquation\n\nconst appendMax = (name: string): string => name + '_max';\n\nconst createEinsumProgramInfo = (\n  inputShapes: Array<readonly number[]>,\n  dataType: number,\n  einsumEquation: EinsumEquation,\n  outputShape: readonly number[],\n): ProgramInfo => {\n  const ranks = inputShapes.map((dims) => dims.length);\n  const inputVars = ranks.map((rank, index) => inputVariable(`input${index}`, dataType, rank));\n  const outputSize = ShapeUtil.size(outputShape);\n  const output = outputVariable('output', dataType, outputShape.length);\n  const uniformsSymbols = [...einsumEquation.symbolToInfo.keys()].filter(\n    (symbol) => !einsumEquation.rhs.symbolToIndices.has(symbol),\n  );\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const idxCopy: string[] = [];\n    const initProd = 'var prod = 1.0;';\n    const initSum = 'var sum = 0.0;';\n    const updateSum = 'sum += prod;';\n    const reduceOpsSetIndices: string[] = [];\n    const reduceOpsLoopHeaders: string[] = [];\n    const reduceOpsLoopFooters: string[] = [];\n    const reduceOpCompute: string[] = [];\n    const isReduceOpsWithoutLoop = einsumEquation.symbolToInfo.size === einsumEquation.rhs.symbolToIndices.size;\n    einsumEquation.symbolToInfo.forEach((info, symbol) => {\n      if (einsumEquation.rhs.symbolToIndices.has(symbol)) {\n        const outputIndex = einsumEquation.rhs.symbolToIndices.get(symbol)?.[0];\n        if (outputIndex !== undefined) {\n          einsumEquation.lhs.forEach((term, i) => {\n            if (info.inputIndices.includes(i)) {\n              const indices = term.symbolToIndices.get(symbol);\n              if (indices === undefined) {\n                throw new Error('Invalid symbol error');\n              }\n              indices.forEach((index) => {\n                idxCopy.push(\n                  `${inputVars[i].indicesSet(\n                    `input${i}Indices`,\n                    index,\n                    output.indicesGet('outputIndices', outputIndex),\n                  )}`,\n                );\n              });\n            }\n          });\n        }\n      } else {\n        einsumEquation.lhs.forEach((term, i) => {\n          if (info.inputIndices.includes(i)) {\n            const indices = term.symbolToIndices.get(symbol);\n            if (indices === undefined) {\n              throw new Error('Invalid symbol error');\n            }\n            indices.forEach((index) => {\n              reduceOpsSetIndices.push(`${inputVars[i].indicesSet(`input${i}Indices`, index, `${symbol}`)}`);\n            });\n            reduceOpCompute.push(`prod *= ${inputVars[i].getByIndices(`input${i}Indices`)};`);\n          }\n        });\n        reduceOpsLoopHeaders.push(\n          `for(var ${symbol}: u32 = 0; ${symbol} < uniforms.${appendMax(symbol)}; ${symbol}++) {`,\n        );\n        reduceOpsLoopFooters.push('}');\n      }\n    });\n    const reduceOps = isReduceOpsWithoutLoop\n      ? [\n          ...idxCopy,\n          `let sum = ${inputVars.map((inputVar, i) => inputVar.getByIndices(`input${i}Indices`)).join(' * ')};`,\n        ]\n      : [\n          ...idxCopy,\n          initSum,\n          ...reduceOpsLoopHeaders,\n          ...reduceOpsSetIndices,\n          initProd,\n          ...reduceOpCompute,\n          updateSum,\n          ...reduceOpsLoopFooters,\n        ];\n    return `\n            ${shaderHelper\n              .registerUniforms(uniformsSymbols.map((symbol) => ({ name: `${appendMax(symbol)}`, type: 'u32' })))\n              .registerUniform('outputSize', 'u32')\n              .declareVariables(...inputVars, output)}\n\n            ${shaderHelper.mainStart()}\n            ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n            var outputIndices = ${output.offsetToIndices('global_idx')};\n            ${inputVars.map((_var, i) => `var input${i}Indices: ${inputVars[i].type.indices};`).join('\\n')}\n            ${reduceOps.join('\\n')};\n            ${output.setByOffset('global_idx', 'sum')};\n          }`;\n  };\n  return {\n    name: 'Einsum',\n    shaderCache: { hint: einsumEquation.equation, inputDependencies: inputShapes.map(() => 'rank') },\n    getRunData: () => {\n      // The symbols from uniformSymbols array are guaranteed to exist in einsumEquations.symbolToInfo map. The\n      // filter is added to make sure that dimValue is never 0.\n      const programUniformsInit: ProgramUniform[] = uniformsSymbols\n        .filter((symbol) => einsumEquation.symbolToInfo.has(symbol))\n        .map((symbol) => ({ type: DataType.uint32, data: einsumEquation.symbolToInfo.get(symbol)?.dimValue || 0 }));\n      programUniformsInit.push({ type: DataType.uint32, data: outputSize });\n      const programUniforms: ProgramUniform[] = inputShapes\n        .map((dims, _) => [...createTensorShapeVariables(dims)])\n        .reduce((acc, inputProgramUniforms) => acc.concat(inputProgramUniforms), programUniformsInit);\n      programUniforms.push(...createTensorShapeVariables(outputShape));\n      return {\n        outputs: [{ dims: outputShape, dataType }],\n        dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n        programUniforms,\n      };\n    },\n    getShaderSource,\n  };\n};\n\nexport const einsum = (context: ComputeContext, attributes: EinsumAttributes): void => {\n  const einsumEquation = new EinsumEquation(context.inputs, attributes.equation);\n  const outputShape = einsumEquation.outputDims;\n  const inputShapes = context.inputs.map((input, _) => input.dims);\n  context.compute(createEinsumProgramInfo(inputShapes, context.inputs[0].dataType, einsumEquation, outputShape));\n};\n\nexport const parseEinsumAttributes = (attributes: Record<string, unknown>): EinsumAttributes => {\n  const equation = (attributes.equation as string).replace(/\\s+/g, '');\n  return createAttributeWithCacheKey({ equation });\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { ComputeContext, ProgramInfo, ProgramUniform } from '../types';\n\nimport { createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper } from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Expand requires 2 input.');\n  }\n  const inputShape = inputs[0].dims;\n  const shape = Array.from(inputs[1].getBigInt64Array(), Number);\n\n  let shapeIndex = shape.length < inputShape.length ? 0 : shape.length - inputShape.length;\n  let inputShapeIndex = inputShape.length < shape.length ? 0 : inputShape.length - shape.length;\n  for (; shapeIndex < shape.length && inputShapeIndex < inputShape.length; ++shapeIndex, ++inputShapeIndex) {\n    if (\n      shape[shapeIndex] !== inputShape[inputShapeIndex] &&\n      shape[shapeIndex] !== 1 &&\n      inputShape[inputShapeIndex] !== 1\n    ) {\n      throw new Error('Expand requires shape to be broadcastable to input');\n    }\n  }\n};\n\nconst getAdjustedShape = (shape1: readonly number[], shape2: readonly number[]): number[] => {\n  const diff = shape1.length - shape2.length;\n  const shape: number[] = [];\n  for (let i = 0; i < diff; ++i) {\n    shape.push(shape1[i]);\n  }\n  for (let i = 0; i < shape2.length; ++i) {\n    shape.push(shape2[i] === 1 ? shape1[i + diff] : shape2[i]);\n  }\n  return shape;\n};\n\nconst calculateOutputShape = (inputShape: readonly number[], shape: readonly number[]): number[] =>\n  inputShape.length > shape.length ? getAdjustedShape(inputShape, shape) : getAdjustedShape(shape, inputShape);\n\nconst createExpandProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const shape = Array.from(inputs[1].getBigInt64Array(), Number);\n  const outputShape: number[] = calculateOutputShape(inputShape, shape);\n  const dataType = inputs[0].dataType;\n  const isBoolOrScalar = dataType === DataType.bool || ShapeUtil.size(inputShape) === 1;\n  const iComponents =\n    dataType === DataType.bool ? 4 : inputShape.length > 0 && inputShape[inputShape.length - 1] % 4 === 0 ? 4 : 1;\n  const components = isBoolOrScalar\n    ? 4\n    : outputShape.length > 0 && outputShape[outputShape.length - 1] % 4 === 0\n      ? 4\n      : 1;\n  const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const input = inputVariable('input', dataType, inputShape.length, iComponents);\n    const output = outputVariable('output', dataType, outputShape.length, components);\n    let assignment: string;\n    if (dataType === DataType.bool) {\n      const singleAssignment = (resStr: string, x: number, typeCast = '') => `\n          let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)};\n          let offset${x} = ${input.broadcastedIndicesToOffset(`outputIndices${x}`, output)};\n          let index${x} = offset${x} / 4u;\n          let component${x} = offset${x} % 4u;\n          ${resStr}[${x}] = ${typeCast}(${input.getByOffset(`index${x}`)}[component${x}]);\n        `;\n      assignment = `\n        let outputOffset = global_idx * ${components};\n        var data = vec4<u32>(0);\n        ${singleAssignment('data', 0, 'u32')}\n        ${singleAssignment('data', 1, 'u32')}\n        ${singleAssignment('data', 2, 'u32')}\n        ${singleAssignment('data', 3, 'u32')}\n        ${output.setByOffset('global_idx', 'data')}\n      }`;\n    } else {\n      assignment = `\n        let outputIndices = ${output.offsetToIndices(`global_idx * ${components}`)};\n        let inputOffset = ${input.broadcastedIndicesToOffset('outputIndices', output)};\n        let data = ${output.type.value}(${input.getByOffset(`inputOffset / ${iComponents}`)});\n        ${output.setByOffset('global_idx', 'data')}\n      }`;\n    }\n    return `\n    ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(input, output)}\n    ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n    ${assignment}`;\n  };\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    ...createTensorShapeVariables(inputShape, outputShape),\n  ];\n  return {\n    name: 'Expand',\n    shaderCache: { hint: `${outputShape.length};${iComponents}${components}`, inputDependencies: ['rank'] },\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n  };\n};\n\nexport const expand = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createExpandProgramInfo(context.inputs), { inputs: [0] });\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { ComputeContext, ProgramInfo } from '../types';\n\nimport {\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  tensorTypeToWsglValueType,\n  UniformsArrayType,\n  WORKGROUP_SIZE,\n} from './common';\nimport * as unary from './unary-op';\n\n// GELU is defined as Y=0.5*X*(1+tanh(0.797885*X+0.035677*X*X*X)), where X may pre-add a bias.\n\nconst createFastGeluProgramInfo = (inputTensors: readonly TensorView[]): ProgramInfo => {\n  const dataType = inputTensors[0].dataType;\n  const outputSize = ShapeUtil.size(inputTensors[0].dims);\n  const biasLength = ShapeUtil.size(inputTensors[1].dims);\n  // can only use vec4 when bias length is multiple of 4\n  const useVec4 = biasLength % 4 === 0;\n  const getShaderSource = (shaderHelper: ShaderHelper): string => {\n    const x = inputVariable('x', dataType, [1], 4);\n    const bias = inputVariable('bias', dataType, [1], 4);\n    const y = outputVariable('y', dataType, [1], 4);\n\n    const uniforms: UniformsArrayType = [\n      { name: 'output_vec_size', type: 'u32' },\n      { name: 'bias_size', type: 'u32' },\n    ];\n\n    const singleElementBias = (i: 0 | 1 | 2 | 3) => `\n      let bias${i}_offset: u32 = (global_idx * 4 + ${i}) % uniforms.bias_size;\n      let bias${i} = ${bias.getByOffset(`bias${i}_offset / 4`)}[bias${i}_offset % 4];`;\n    const biasGetExpression = useVec4\n      ? `\n      let bias = ${bias.getByOffset('global_idx % (uniforms.bias_size / 4)')};`\n      : `${singleElementBias(0)}${singleElementBias(1)}${singleElementBias(2)}${singleElementBias(3)}\n      let bias = ${x.type.value}(bias0, bias1, bias2, bias3);`;\n\n    return `${shaderHelper.registerUniforms(uniforms).declareVariables(x, bias, y)}\n\n    ${unary.fastGeluImpl(tensorTypeToWsglValueType(dataType))}\n\n    ${shaderHelper.mainStart(WORKGROUP_SIZE)}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_vec_size')}\n\n      let x = ${x.getByOffset('global_idx')};\n      ${biasGetExpression}\n      let x_in = x + bias;\n      ${y.setByOffset('global_idx', unary.fastGeluExpression('x_in'))}\n    }`;\n  };\n\n  return {\n    name: 'FastGeluWithBias',\n    shaderCache: { hint: `${useVec4}`, inputDependencies: ['type', 'type'] },\n    getShaderSource,\n    getRunData: (inputs) => ({\n      outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }],\n      programUniforms: [\n        { type: DataType.uint32, data: Math.ceil(outputSize / 4) },\n        { type: DataType.uint32, data: biasLength },\n      ],\n      dispatchGroup: { x: Math.ceil(outputSize / WORKGROUP_SIZE / 4) },\n    }),\n  };\n};\n\nexport const fastGelu = (context: ComputeContext): void => {\n  if (context.inputs.length < 2 || ShapeUtil.size(context.inputs[1].dims) === 0) {\n    unary.fastGelu(context);\n  } else {\n    context.compute(createFastGeluProgramInfo(context.inputs));\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramUniform } from '../types';\n\nimport { createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper } from './common';\n\nexport interface GatherAttributes extends AttributeWithCacheKey {\n  axis: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Gather requires 2 inputs.');\n  }\n};\n\nconst createGatherProgramInfo = (inputs: readonly TensorView[], attributes: GatherAttributes): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const indicesShape = inputs[1].dims;\n\n  const inputRank = inputShape.length;\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);\n\n  const outputShape = inputShape.slice(0);\n  outputShape.splice(axis, 1, ...indicesShape);\n\n  const axisDimLimit = inputShape[axis];\n  const components = inputs[0].dataType === DataType.bool ? 4 : 1;\n  const outputSize = Math.ceil(ShapeUtil.size(outputShape) / components);\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.int32, data: axisDimLimit },\n    { type: DataType.uint32, data: axis },\n    ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, outputShape),\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const data = inputVariable('data', inputs[0].dataType, inputs[0].dims.length, components);\n    const indices = inputVariable('inputIndices', inputs[1].dataType, inputs[1].dims.length);\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length, components);\n\n    const calcDataIndices = (x: number | string): string => {\n      const indicesRank = indicesShape.length;\n      let calcStr = `var indicesIndices${x}  = ${indices.type.indices}(0);`;\n      for (let i = 0; i < indicesRank; i++) {\n        calcStr += `${indicesRank > 1 ? `indicesIndices${x}[${i}]` : `indicesIndices${x}`} = ${\n          outputShape.length > 1 ? `outputIndices${x}[uniforms.axis + ${i}]` : `outputIndices${x}`\n        };`;\n      }\n      calcStr += `\n          var idx${x} = ${indices.getByIndices(`indicesIndices${x}`)};\n          if (idx${x} < 0) {\n            idx${x} = idx${x} + uniforms.axisDimLimit;\n          }\n          var dataIndices${x} : ${data.type.indices};\n        `;\n      for (let i = 0, j = 0; i < inputRank; i++) {\n        if (i === axis) {\n          calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = u32(idx${x});`;\n          j += indicesRank;\n        } else {\n          calcStr += `${inputRank > 1 ? `dataIndices${x}[${i}]` : `dataIndices${x}`} = ${\n            outputShape.length > 1 ? `outputIndices${x}[${j}]` : `outputIndices${x}`\n          };`;\n          j++;\n        }\n      }\n      return calcStr;\n    };\n    let assignment: string;\n    if (inputs[0].dataType === DataType.bool) {\n      const singleAssignment = (resStr: string, x: number, typeCast = '') => `\n          let outputIndices${x} = ${output.offsetToIndices(`outputOffset + ${x}u`)};\n          ${calcDataIndices(x)};\n          let offset${x} = ${data.indicesToOffset(`dataIndices${x}`)};\n          let index${x} = offset${x} / 4u;\n          let component${x} = offset${x} % 4u;\n          ${resStr}[${x}] = ${typeCast}(${data.getByOffset(`index${x}`)}[component${x}]);\n        `;\n      assignment = `\n        let outputOffset = global_idx * ${components};\n        var value = vec4<u32>(0);\n        ${singleAssignment('value', 0, 'u32')}\n        ${singleAssignment('value', 1, 'u32')}\n        ${singleAssignment('value', 2, 'u32')}\n        ${singleAssignment('value', 3, 'u32')}\n        ${output.setByOffset('global_idx', 'value')}\n      `;\n    } else {\n      assignment = `\n      let outputIndices = ${output.offsetToIndices('global_idx')};\n      ${calcDataIndices('')};\n      let value = ${data.getByIndices('dataIndices')};\n      ${output.setByOffset('global_idx', 'value')};\n      `;\n    }\n    return `\n      ${shaderHelper\n        .registerUniform('outputSize', 'u32')\n        .registerUniform('axisDimLimit', 'i32')\n        .registerUniform('axis', 'u32')\n        .declareVariables(data, indices, output)}\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n        ${assignment}\n      }`;\n  };\n  return {\n    name: 'Gather',\n    shaderCache: { hint: attributes.cacheKey, inputDependencies: ['rank', 'rank'] },\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n\nexport const parseGatherAttributes = (attributes: Record<string, unknown>): GatherAttributes =>\n  createAttributeWithCacheKey({ axis: attributes.axis as number });\n\nexport const gather = (context: ComputeContext, attributes: GatherAttributes): void => {\n  const inputs = context.inputs;\n  validateInputs(inputs);\n  context.compute(createGatherProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramUniform } from '../types';\n\nimport { createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper, UniformsArrayType } from './common';\n\nexport interface GatherNDAttributes extends AttributeWithCacheKey {\n  readonly batchDims: number;\n}\n\nconst computeSliceOffsets = (\n  context: ComputeContext,\n  indicesData: TensorView,\n  sizesFromSliceDimsData: number[],\n  batchDims: number,\n  inputDims: readonly number[],\n  numSlices: number,\n  numSlicesPerBatch: number,\n  inputBatchStride: number,\n  numSliceDims: number,\n) => {\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: numSlices },\n    { type: DataType.uint32, data: batchDims },\n    { type: DataType.uint32, data: inputDims },\n    { type: DataType.uint32, data: sizesFromSliceDimsData },\n    { type: DataType.uint32, data: numSlicesPerBatch },\n    { type: DataType.uint32, data: inputBatchStride },\n    { type: DataType.uint32, data: numSliceDims },\n  ];\n\n  const outputShape = [numSlices];\n  programUniforms.push(...createTensorShapeVariables(indicesData.dims, outputShape));\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const indices = inputVariable('indices_data', indicesData.dataType, indicesData.dims.length);\n    const output = outputVariable('input_slice_offsets_data', DataType.uint32, 1, 1);\n    const variables = [indices, output];\n    const uniforms: UniformsArrayType = [\n      { name: 'output_size', type: 'u32' },\n      { name: 'batch_dims', type: 'u32' },\n      { name: 'input_dims', type: 'u32', length: inputDims.length },\n      { name: 'sizes_from_slice_dims_data', type: 'u32', length: sizesFromSliceDimsData.length },\n      { name: 'num_slices_per_batch', type: 'u32' },\n      { name: 'input_batch_stride', type: 'u32' },\n      { name: 'num_slice_dims', type: 'u32' },\n    ];\n    return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    let batch_idx = global_idx / uniforms.num_slices_per_batch;\n    let base_offset = batch_idx * uniforms.input_batch_stride;\n\n    let slice_indices_base_offset = global_idx * uniforms.num_slice_dims;\n    var relative_slice_offset = 0;\n    for (var dim_idx = 0u; dim_idx < uniforms.num_slice_dims; dim_idx ++) {\n      var index = i32(indices_data[dim_idx + slice_indices_base_offset].x);\n      let input_dim_idx = uniforms.batch_dims + dim_idx;\n      if (index < 0) {\n        ${\n          inputDims.length === 1\n            ? 'index += i32(uniforms.input_dims);'\n            : 'index += i32(uniforms.input_dims[input_dim_idx]);'\n        }\n      }\n      ${\n        sizesFromSliceDimsData.length === 1\n          ? 'relative_slice_offset += index * i32(uniforms.sizes_from_slice_dims_data);'\n          : 'relative_slice_offset += index * i32(uniforms.sizes_from_slice_dims_data[dim_idx]);'\n      }\n    }\n\n    input_slice_offsets_data[global_idx] =  base_offset + u32(relative_slice_offset);\n  }`;\n  };\n\n  return context.compute(\n    {\n      name: 'computeSliceOffsets',\n      shaderCache: { hint: `${inputDims.length}_${sizesFromSliceDimsData.length}`, inputDependencies: ['rank'] },\n      getRunData: () => ({\n        outputs: [{ dims: outputShape, dataType: context.inputs[1].dataType }],\n        dispatchGroup: { x: Math.ceil(numSlices / 64) },\n        programUniforms,\n      }),\n      getShaderSource,\n    },\n    { inputs: [indicesData], outputs: [-1] },\n  )[0];\n};\n\nexport const gatherND = (context: ComputeContext, attributes: GatherNDAttributes) => {\n  const inputs = context.inputs;\n  const inputShape = inputs[0].dims;\n  const inputType = inputs[0].dataType;\n  const indicesShape = inputs[1].dims;\n  const numSliceDims = indicesShape[indicesShape.length - 1];\n  const numSlices = ShapeUtil.sizeToDimension(indicesShape, indicesShape.length - 1);\n  const sliceSize = ShapeUtil.sizeFromDimension(inputShape, attributes.batchDims + numSliceDims);\n  const numBatches = ShapeUtil.sizeToDimension(inputShape, attributes.batchDims);\n  const inputBatchStride = ShapeUtil.sizeFromDimension(inputShape, attributes.batchDims);\n  const numSlicesPerBatch = numSlices / numBatches;\n  const sizesFromSliceDims = new Array(numSliceDims);\n  let runningProduct = sliceSize;\n  for (let i = 0; i < numSliceDims; ++i) {\n    sizesFromSliceDims[numSliceDims - 1 - i] = runningProduct;\n    runningProduct *= inputShape[attributes.batchDims + numSliceDims - 1 - i];\n  }\n\n  const inputSliceOffsets = computeSliceOffsets(\n    context,\n    inputs[1],\n    sizesFromSliceDims,\n    attributes.batchDims,\n    inputShape,\n    numSlices,\n    numSlicesPerBatch,\n    inputBatchStride,\n    numSliceDims,\n  );\n\n  const lastIndicesDimension = attributes.batchDims + numSliceDims;\n  if (lastIndicesDimension > inputShape.length) {\n    throw new Error('last dimension of indices must not be larger than rank of input tensor');\n  }\n\n  const outputShape = indicesShape.slice(0, -1).concat(inputShape.slice(lastIndicesDimension));\n  const outputSize = ShapeUtil.size(outputShape);\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.uint32, data: sliceSize },\n    ...createTensorShapeVariables(inputs[0].dims, inputSliceOffsets.dims, outputShape),\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const input = inputVariable('data', inputs[0].dataType, inputs[0].dims.length);\n    const indices = inputVariable('slice_offsets', DataType.uint32, inputSliceOffsets.dims.length);\n\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n    return `\n          ${shaderHelper\n            .registerUniform('output_size', 'u32')\n            .registerUniform('slice_size', 'u32')\n            .declareVariables(input, indices, output)}\n            ${shaderHelper.mainStart()}\n            ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n          let slice_offset = slice_offsets[global_idx / uniforms.slice_size];\n          output[global_idx] = data[u32(slice_offset) + global_idx % uniforms.slice_size];\n        }`;\n  };\n  context.compute(\n    {\n      name: 'GatherND',\n      shaderCache: { hint: attributes.cacheKey, inputDependencies: ['rank', 'rank'] },\n      getRunData: () => ({\n        outputs: [{ dims: outputShape, dataType: inputType }],\n        dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n        programUniforms,\n      }),\n      getShaderSource,\n    },\n    { inputs: [inputs[0], inputSliceOffsets] },\n  );\n};\n\nexport const parseGatherNDAttributes = (attributes: Record<string, unknown>): GatherNDAttributes => {\n  const batchDims = attributes.batch_dims as number;\n  return {\n    batchDims,\n    cacheKey: '',\n  };\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramUniform } from '../types';\n\nimport {\n  createTensorShapeVariables,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  tensorTypeToWsglValueType,\n  UniformsArrayType,\n} from './common';\n\nexport interface GatherBlockQuantizedAttributes extends AttributeWithCacheKey {\n  gatherAxis: number;\n  quantizeAxis: number;\n  blockSize: number;\n}\n\nexport const validateInputs = (inputs: readonly TensorView[], attributes: GatherBlockQuantizedAttributes): void => {\n  if (inputs.length < 3 || inputs.length > 4) {\n    throw new Error('GatherBlockQuantized requires 3 or 4 inputs.');\n  }\n  const quantizeAxis = ShapeUtil.normalizeAxis(attributes.quantizeAxis, inputs[0].dims.length);\n  const blockSize = attributes.blockSize;\n  const data = inputs[0];\n  const scales = inputs[2];\n  const zeroPoint = inputs.length === 4 ? inputs[3] : undefined;\n  if (\n    scales.dims.length !== data.dims.length ||\n    !data.dims\n      .map((d, i) => (i === quantizeAxis ? Math.ceil(d / blockSize) === scales.dims[i] : d === scales.dims[i]))\n      .reduce((a, b) => a && b, true)\n  ) {\n    throw new Error(\n      'Scales must have the same rank as the input tensor and the dims should match except on gatherAxis.',\n    );\n  }\n  // TODO Uncomment the following check once the test case creation code is fixed to create data correctly aligned.\n  // const indices = inputs[1];\n  // const validIndex = (index: number) => index >= 0 && index < data.dims[attributes.gatherAxis];\n  // if (indices.dataType === DataType.int32 && indices.getInt32Array().some((v) => !validIndex(v)) ||\n  //     indices.dataType === DataType.int64 && indices.getBigInt64Array().some((v) => !validIndex(Number(v)))) {\n  //   throw new Error('Indices must be within the bounds of the gatherAxis.');\n  // }\n  if (zeroPoint) {\n    if (zeroPoint.dataType !== data.dataType) {\n      throw new Error('Zero point must have the same data type as the input tensor.');\n    }\n    if (\n      zeroPoint.dims.length !== scales.dims.length ||\n      !zeroPoint.dims.map((d, i) => d === scales.dims[i]).reduce((a, b) => a && b, true)\n    ) {\n      throw new Error(\n        'Zero point must have the same rank as the input tensor and the dims should match except on quantizeAxis.',\n      );\n    }\n  }\n};\n\nconst createGatherBlockQuantizedProgramInfo = (\n  inputs: readonly TensorView[],\n  attributes: GatherBlockQuantizedAttributes,\n): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const indicesShape = inputs[1].dims;\n  const inputRank = inputShape.length;\n  const gatherAxis = ShapeUtil.normalizeAxis(attributes.gatherAxis, inputRank);\n  const quantizeAxis = ShapeUtil.normalizeAxis(attributes.quantizeAxis, inputRank);\n  const outputShape = inputShape.slice(0);\n  outputShape.splice(gatherAxis, 1, ...indicesShape);\n  const outputSize = ShapeUtil.size(outputShape);\n  const outputType = inputs[2].dataType;\n  const inputType = inputs[0].dataType;\n  const isSigned = inputType === DataType.int4; // input data type is either int4 or uint4.\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.uint32, data: quantizeAxis },\n    { type: DataType.uint32, data: gatherAxis },\n    { type: DataType.uint32, data: attributes.blockSize },\n    ...createTensorShapeVariables(...inputs.map((input, _) => input.dims), outputShape),\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const data = inputVariable('data', inputs[0].dataType, inputs[0].dims.length);\n    const indices = inputVariable('inputIndices', inputs[1].dataType, inputs[1].dims.length);\n    const scales = inputVariable('scales', inputs[2].dataType, inputs[2].dims.length);\n    const zeroPoint =\n      inputs.length > 3 ? inputVariable('zeroPoint', inputs[3].dataType, inputs[3].dims.length) : undefined;\n    const output = outputVariable('output', outputType, outputShape.length);\n    const inputVariables = [data, indices, scales];\n    if (zeroPoint) {\n      inputVariables.push(zeroPoint);\n    }\n    const uniforms: UniformsArrayType = [\n      { name: 'output_size', type: 'u32' },\n      { name: 'quantize_axis', type: 'u32' },\n      { name: 'gather_axis', type: 'u32' },\n      { name: 'block_size', type: 'u32' },\n    ];\n    return `\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n        ${shaderHelper.mainStart()}\n        let output_indices = ${output.offsetToIndices('global_idx')};\n        var indices_indices = ${indices.type.indices}(0);\n        ${(() => {\n          if (indicesShape.length > 1) {\n            return `\n          for (var i: u32 = 0; i < ${indicesShape.length}; i++) {\n            let index = ${output.indicesGet('output_indices', 'uniforms.gather_axis + i')};\n            ${indices.indicesSet('indices_indices', 'i', 'index')};\n          }`;\n          } else {\n            return `indices_indices = ${output.indicesGet('output_indices', 'uniforms.gather_axis')};`;\n          }\n        })()};\n        var data_indices = ${data.type.indices}(0);\n        for (var i: u32 = 0; i < uniforms.gather_axis; i++) {\n          let index = ${output.indicesGet('output_indices', 'i')};\n          ${data.indicesSet('data_indices', 'i', 'index')};\n        }\n        var index_from_indices = ${indices.getByIndices('indices_indices')};\n        if (index_from_indices < 0) {\n          index_from_indices += ${inputShape[gatherAxis]};\n        }\n        ${data.indicesSet('data_indices', 'uniforms.gather_axis', 'u32(index_from_indices)')};\n        for (var i = uniforms.gather_axis + 1; i < ${outputShape.length}; i++) {\n          let index = ${output.indicesGet('output_indices', `i + ${indicesShape.length} - 1`)};\n          ${data.indicesSet('data_indices', 'i', 'index')};\n        }\n        let data_offset = ${data.indicesToOffset('data_indices')};\n        let data_index = data_offset % 8;\n        // Convert 4-bit packed data to 8-bit packed data.\n        let packed_4bit_quantized_data = ${data.getByOffset('data_offset / 8')};\n        let packed_8bit_quantized_data = (packed_4bit_quantized_data >> (4 * (data_index % 2))) & 0x0f0f0f0f;\n        let quantized_data_vec = ${isSigned ? 'unpack4xI8' : 'unpack4xU8'}(u32(packed_8bit_quantized_data));\n        let quantized_data = quantized_data_vec[data_index / 2];\n        var scale_indices = data_indices;\n        let quantize_axis_index = ${scales.indicesGet('data_indices', 'uniforms.quantize_axis')} / uniforms.block_size;\n        ${scales.indicesSet('scale_indices', 'uniforms.quantize_axis', 'quantize_axis_index')};\n        var scale = ${scales.getByIndices('scale_indices')};\n        ${(() => {\n          if (!zeroPoint) {\n            return 'var zero_point = 0';\n          } else {\n            return `\n              let zero_point_indices = scale_indices;\n              let zero_point_offset = ${zeroPoint.indicesToOffset('zero_point_indices')};\n              let zero_point_index = zero_point_offset % 8;\n              let packed_4bit_zero_points = ${zeroPoint.getByOffset('zero_point_offset / 8')};\n              let packed_8bit_zero_points = (packed_4bit_zero_points >> (4 * (zero_point_index % 2))) & 0x0f0f0f0f;\n              let zero_point_vec = ${isSigned ? 'unpack4xI8' : 'unpack4xU8'}(u32(packed_8bit_zero_points));\n              let zero_point = zero_point_vec[zero_point_index / 2];`;\n          }\n        })()};\n        let dequantized_data = ${tensorTypeToWsglValueType(outputType)}(quantized_data - zero_point) * scale;\n        ${output.setByOffset('global_idx', 'dequantized_data')};\n    }`;\n  };\n  return {\n    name: 'GatherBlockQuantized',\n    shaderCache: {\n      hint: `${attributes.cacheKey};${inputs\n        .filter((_, i) => i !== 1)\n        .map((input) => input.dims.join('_'))\n        .join(';')}`,\n      inputDependencies: Array.from({ length: inputs.length }, (_v, _i) => 'rank'),\n    },\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: outputType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n\nexport const gatherBlockQuantized = (context: ComputeContext, attributes: GatherBlockQuantizedAttributes): void => {\n  const inputs = context.inputs;\n  validateInputs(inputs, attributes);\n  context.compute(createGatherBlockQuantizedProgramInfo(context.inputs, attributes));\n};\n\nexport const parseGatherBlockQuantizedAttributes = (\n  attributes: Record<string, unknown>,\n): GatherBlockQuantizedAttributes =>\n  createAttributeWithCacheKey({\n    blockSize: attributes.blockSize as number,\n    gatherAxis: attributes.gatherAxis as number,\n    quantizeAxis: attributes.quantizeAxis as number,\n  });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform } from '../types';\n\nimport { createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper } from './common';\n\nexport interface GatherElementsAttributes extends AttributeWithCacheKey {\n  axis: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('GatherElements requires 2 inputs.');\n  }\n\n  if (inputs[0].dims.length < 1) {\n    throw new Error('GatherElements requires that the data input be rank >= 1.');\n  }\n\n  if (inputs[0].dims.length !== inputs[1].dims.length) {\n    throw new Error(`GatherElements requires that the data input and\n                     indices input tensors be of same rank.`);\n  }\n};\n\nconst createGatherElementsProgramInfo = (\n  inputs: readonly TensorView[],\n  attributes: GatherElementsAttributes,\n): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const inputOutputDataType = inputs[0].dataType;\n  const inputRank = inputShape.length;\n\n  const indicesShape = inputs[1].dims;\n  const indicesDataType = inputs[1].dataType;\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);\n  const axisDimLimit = inputShape[axis];\n\n  const outputShape = indicesShape.slice(0);\n  const outputSize = ShapeUtil.size(outputShape);\n\n  const input = inputVariable('input', inputOutputDataType, inputRank);\n  const indices = inputVariable('indicesInput', indicesDataType, indicesShape.length);\n  const output = outputVariable('output', inputOutputDataType, outputShape.length);\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.int32, data: axisDimLimit },\n    { type: DataType.uint32, data: axis },\n  ];\n  programUniforms.push(...createTensorShapeVariables(inputShape, indicesShape, outputShape));\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'rank'];\n\n  // int64 indices would be treated as little endian i32 with assumption they fall in i32 limits\n  // That assumption is safe as it's not possible to allocate >2gb buffer for input tensor\n  // Input data will be treated as u32 or two u32 for 8-byte tensors\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n      ${shaderHelper\n        .registerUniform('outputSize', 'u32')\n        .registerUniform('axisDimLimit', 'i32')\n        .registerUniform('axis', 'u32')\n        .declareVariables(input, indices, output)}\n      ${shaderHelper.mainStart()}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n\n      let outputIndices = ${output.offsetToIndices('global_idx')};\n\n      var idx = ${indices.getByOffset('global_idx')};\n      if (idx < 0) {\n        idx = idx + uniforms.axisDimLimit;\n      }\n      var inputIndices = ${input.type.indices}(outputIndices);\n      ${input.indicesSet('inputIndices', 'uniforms.axis', 'u32(idx)')};\n      let value = ${input.getByIndices('inputIndices')};\n\n      ${output.setByOffset('global_idx', 'value')};\n  }`;\n\n  return {\n    name: 'GatherElements',\n    shaderCache: { inputDependencies },\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n\nexport const parseGatherElementsAttributes = (attributes: Record<string, unknown>): GatherElementsAttributes =>\n  createAttributeWithCacheKey({ axis: attributes.axis as number });\n\nexport const gatherElements = (context: ComputeContext, attributes: GatherElementsAttributes): void => {\n  const inputs = context.inputs;\n  validateInputs(inputs);\n  context.compute(createGatherElementsProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { GemmUtil, ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform } from '../types';\n\nimport {\n  createTensorShapeVariables,\n  IndicesHelper,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  UniformsArrayType,\n} from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs) {\n    throw new Error('Input is missing');\n  }\n  if (inputs.length < 2 || inputs.length > 3) {\n    throw new Error('Invaid input number.');\n  }\n\n  // 'C' can be of dimensionality 0, 1 or 2 only\n  if (inputs.length === 3 && inputs[2].dims.length > 2) {\n    throw new Error('Invalid input shape of C');\n  }\n\n  if (inputs[0].dataType !== inputs[1].dataType || (inputs.length === 3 && inputs[0].dataType !== inputs[2].dataType)) {\n    throw new Error('Input types are mismatched');\n  }\n};\n\nexport interface GemmAttributes extends AttributeWithCacheKey {\n  transA: boolean;\n  transB: boolean;\n  alpha: number;\n  beta: number;\n}\n\nconst createGemmProgramInfo = (inputs: readonly TensorView[], attributes: GemmAttributes): ProgramInfo => {\n  const aShape = inputs[0].dims.slice();\n  const bShape = inputs[1].dims.slice();\n  const [M, N, K] = 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  const tileSize = 16;\n  const numTileN = Math.ceil(N / tileSize);\n  const numTileM = Math.ceil(M / tileSize);\n  // TODO: Find the condition when to use the naive one.\n  const useShared = true;\n\n  const outputSize = ShapeUtil.size(outputShape);\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: useShared ? numTileN : outputSize },\n    { type: DataType.uint32, data: M },\n    { type: DataType.uint32, data: N },\n    { type: DataType.uint32, data: K },\n    { type: DataType.float, data: attributes.alpha },\n    { type: DataType.float, data: attributes.beta },\n  ];\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n  if (inputs.length === 3) {\n    programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n    inputDependencies.push('rank');\n  }\n  programUniforms.push(...createTensorShapeVariables(outputShape));\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    let line = '';\n    if (attributes.transA && attributes.transB) {\n      line = 'value += a[k * uniforms.M + m] * b[n * uniforms.K + k];';\n    } else if (attributes.transA && !attributes.transB) {\n      line = 'value += a[k * uniforms.M + m] * b[k * uniforms.N + n];';\n    } else if (!attributes.transA && attributes.transB) {\n      line = 'value += a[m * uniforms.K + k] * b[n * uniforms.K + k];';\n    } else if (!attributes.transA && !attributes.transB) {\n      line = 'value += a[m * uniforms.K + k] * b[k * uniforms.N + n];';\n    }\n\n    const calculateAlpha = attributes.alpha === 1 ? '' : 'value *= uniforms.alpha;';\n    const a = inputVariable('a', inputs[0].dataType, inputs[0].dims);\n    const b = inputVariable('b', inputs[1].dataType, inputs[1].dims);\n    const dataType = a.type.value;\n    let c: IndicesHelper | null = null;\n    const variables = [a, b];\n    if (inputs.length === 3) {\n      c = inputVariable('c', inputs[2].dataType, inputs[2].dims.length);\n      variables.push(c);\n    }\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n    variables.push(output);\n    const uniforms: UniformsArrayType = [\n      { name: 'output_size', type: 'u32' },\n      { name: 'M', type: 'u32' },\n      { name: 'N', type: 'u32' },\n      { name: 'K', type: 'u32' },\n      { name: 'alpha', type: 'f32' },\n      { name: 'beta', type: 'f32' },\n    ];\n    return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n    let m = global_idx / uniforms.N;\n    let n = global_idx % uniforms.N;\n\n    var value = ${dataType}(0);\n    for (var k: u32 = 0u; k < uniforms.K; k++) {\n      ${line}\n    }\n\n    ${calculateAlpha}\n    ${(() => {\n      if (c != null) {\n        return `let cOffset = ${c.broadcastedIndicesToOffset('vec2(m, n)', output)}; value += ${\n          dataType\n        }(uniforms.beta) * ${c.getByOffset('cOffset')};`;\n      }\n      return '';\n    })()}\n    output[global_idx] = value;\n  }`;\n  };\n\n  const getShaderSourceShared = (shaderHelper: ShaderHelper) => {\n    const a = inputVariable('a', inputs[0].dataType, inputs[0].dims);\n    const b = inputVariable('b', inputs[1].dataType, inputs[1].dims);\n    let c: IndicesHelper | null = null;\n    const variables = [a, b];\n    if (inputs.length === 3) {\n      c = inputVariable('c', inputs[2].dataType, inputs[2].dims.length);\n      variables.push(c);\n    }\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n    variables.push(output);\n    const uniforms: UniformsArrayType = [\n      { name: 'num_tile_n', type: 'u32' },\n      { name: 'M', type: 'u32' },\n      { name: 'N', type: 'u32' },\n      { name: 'K', type: 'u32' },\n      { name: 'alpha', type: 'f32' },\n      { name: 'beta', type: 'f32' },\n    ];\n\n    let calcResult = '';\n    let fillWorkgroupMemory = '';\n    if (attributes.transA && attributes.transB) {\n      fillWorkgroupMemory = `\n      var col = tile_row_start + local_id.x;\n      var row = k_start + local_id.y;\n      if (col < uniforms.M && row < uniforms.K) {\n        tile_a[local_id.y][local_id.x] = a[row * uniforms.M + col];\n      } else {\n        tile_a[local_id.y][local_id.x] = ${a.type.value}(0);\n      }\n\n      col = k_start + local_id.x;\n      row = tile_col_start + local_id.y;\n      if (col < uniforms.K && row < uniforms.N) {\n        tile_b[local_id.y][local_id.x] = b[row * uniforms.K + col];\n      } else {\n        tile_b[local_id.y][local_id.x] = ${b.type.value}(0);\n      }\n      `;\n      calcResult = `value += tile_a[k][local_id.y] * tile_b[local_id.x][k];`;\n    } else if (attributes.transA && !attributes.transB) {\n      fillWorkgroupMemory = `\n      var col = tile_row_start + local_id.x;\n      var row = k_start + local_id.y;\n      if (col < uniforms.M && row < uniforms.K) {\n        tile_a[local_id.y][local_id.x] = a[row * uniforms.M + col];\n      } else {\n        tile_a[local_id.y][local_id.x] = ${a.type.value}(0);\n      }\n\n      col = tile_col_start + local_id.x;\n      row = k_start + local_id.y;\n      if (col < uniforms.N && row < uniforms.K) {\n        tile_b[local_id.y][local_id.x] = b[row * uniforms.N + col];\n      } else {\n        tile_b[local_id.y][local_id.x] = ${b.type.value}(0);\n      }\n      `;\n      calcResult = `value += tile_a[k][local_id.y] * tile_b[k][local_id.x];`;\n    } else if (!attributes.transA && attributes.transB) {\n      fillWorkgroupMemory = `\n      var col = k_start + local_id.x;\n      var row = tile_row_start + local_id.y;\n      if (col < uniforms.K && row < uniforms.M) {\n        tile_a[local_id.y][local_id.x] = a[row * uniforms.K + col];\n      } else {\n        tile_a[local_id.y][local_id.x] = ${a.type.value}(0);\n      }\n\n      col = k_start + local_id.x;\n      row = tile_col_start + local_id.y;\n      if (col < uniforms.K && row < uniforms.N) {\n        tile_b[local_id.y][local_id.x] = b[row * uniforms.K + col];\n      } else {\n        tile_b[local_id.y][local_id.x] = ${b.type.value}(0);\n      }\n      `;\n      calcResult = `value += tile_a[local_id.y][k] * tile_b[local_id.x][k];`;\n    } else if (!attributes.transA && !attributes.transB) {\n      fillWorkgroupMemory = `\n      var col = k_start + local_id.x;\n      var row = tile_row_start + local_id.y;\n      if (col < uniforms.K && row < uniforms.M) {\n        tile_a[local_id.y][local_id.x] = a[row * uniforms.K + col];\n      } else {\n        tile_a[local_id.y][local_id.x] = ${a.type.value}(0);\n      }\n\n      col = tile_col_start + local_id.x;\n      row = k_start + local_id.y;\n      if (col < uniforms.N && row < uniforms.K) {\n        tile_b[local_id.y][local_id.x] = b[row * uniforms.N + col];\n      } else {\n        tile_b[local_id.y][local_id.x] = ${b.type.value}(0);\n      }\n      `;\n      calcResult = `value += tile_a[local_id.y][k] * tile_b[k][local_id.x];`;\n    }\n\n    const calculateAlpha = attributes.alpha === 1 ? '' : 'value *= uniforms.alpha;';\n\n    return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n  var<workgroup> tile_a: array<array<${a.type.storage}, ${tileSize}>, ${tileSize}>;\n  var<workgroup> tile_b: array<array<${b.type.storage}, ${tileSize}>, ${tileSize}>;\n  ${shaderHelper.mainStart([tileSize, tileSize, 1])}\n    let tile_col_start = (workgroup_index % uniforms.num_tile_n) * ${tileSize};\n    let tile_row_start = (workgroup_index / uniforms.num_tile_n) * ${tileSize};\n    let num_tiles = (uniforms.K - 1) / ${tileSize} + 1;\n    var k_start = 0u;\n    var value = ${output.type.value}(0);\n    for (var t: u32 = 0u; t < num_tiles; t++) {\n      ${fillWorkgroupMemory}\n      k_start = k_start + ${tileSize};\n      workgroupBarrier();\n\n      for (var k: u32 = 0u; k < ${tileSize}; k++) {\n        ${calcResult}\n      }\n      workgroupBarrier();\n    }\n\n    ${calculateAlpha}\n    let m = tile_row_start + local_id.y;\n    let n = tile_col_start + local_id.x;\n    ${(() => {\n      if (c != null) {\n        return `let cOffset = ${c.broadcastedIndicesToOffset('vec2(m, n)', output)}; value += ${\n          output.type.value\n        }(uniforms.beta) * ${c.getByOffset('cOffset')};`;\n      }\n      return '';\n    })()}\n    if (m < uniforms.M && n < uniforms.N) {\n      output[m * uniforms.N + n] = value;\n    }\n  }`;\n  };\n\n  if (useShared) {\n    return {\n      name: 'GemmShared',\n      shaderCache: { hint: `${attributes.cacheKey}`, inputDependencies },\n      getRunData: () => ({\n        outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n        dispatchGroup: { x: numTileN * numTileM },\n        programUniforms,\n      }),\n      getShaderSource: getShaderSourceShared,\n    };\n  }\n\n  return {\n    name: 'Gemm',\n    shaderCache: { hint: `${attributes.cacheKey}`, inputDependencies },\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n\nexport const parseGemmAttributes = (attributes: Record<string, unknown>): GemmAttributes => {\n  const transA = attributes.transA as boolean;\n  const transB = attributes.transB as boolean;\n  const alpha = attributes.alpha as number;\n  const beta = attributes.beta as number;\n  return {\n    transA,\n    transB,\n    alpha,\n    beta,\n    cacheKey: `${attributes.transA};${attributes.transB};${attributes.alpha === 1}`,\n  };\n};\n\nexport const gemm = (context: ComputeContext, attributes: GemmAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createGemmProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramUniform } from '../types';\n\nimport { createTensorShapeVariables, IndicesHelper, inputVariable, outputVariable, ShaderHelper } from './common';\n\nlet [idxN, idxC, idxH, idxW] = [0, 1, 2, 3]; // NCHW\ntype Mode = 'bilinear' | 'nearest' | 'bicubic';\ntype PaddingMode = 'zeros' | 'border' | 'reflection';\ntype Format = 'NHWC' | 'NCHW';\nexport interface GridSampeAttributes extends AttributeWithCacheKey {\n  alignCorners: number;\n  mode: Mode;\n  paddingMode: PaddingMode;\n  format: Format;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (inputs[0].dims.length !== 4) {\n    throw new Error('only 4-D tensor is supported.');\n  }\n  if (inputs[0].dims.length !== inputs[1].dims.length) {\n    throw new Error('input dimensions must be equal to grid dimensions');\n  }\n\n  if (inputs[0].dims.length - 2 !== inputs[1].dims[inputs[1].dims.length - 1]) {\n    throw new Error(`last dimension of grid must be equal to ${inputs[0].dims.length - 2}`);\n  }\n\n  if (inputs[0].dims[0] !== inputs[1].dims[0]) {\n    throw new Error('grid batch size must match input batch size');\n  }\n};\n\nconst gsGetCubicCoeffs = `\n  fn gs_get_cubic_coeffs(x: f32) -> vec4<f32> {\n    let cubic_alpha = -0.75f;\n    let x_abs = abs(x);\n    var coeffs: vec4<f32>;\n    coeffs[0] = (((cubic_alpha * (x_abs + 1) - 5 * cubic_alpha) * (x_abs + 1) + 8 * cubic_alpha) * (x_abs + 1) - 4 * cubic_alpha);\n    coeffs[1] = (((cubic_alpha + 2) * x_abs - (cubic_alpha + 3)) * x_abs * x_abs + 1);\n    coeffs[2] = (((cubic_alpha + 2) * (1 - x_abs) - (cubic_alpha + 3)) * (1 - x_abs) * (1 - x_abs) + 1);\n    coeffs[3] = (((cubic_alpha * (2 - x_abs) - 5 * cubic_alpha) * (2 - x_abs) + 8 * cubic_alpha) * (2 - x_abs) - 4 * cubic_alpha);\n    return coeffs;\n  }\n`;\n\nconst gsBicubicInterpolate = (dataType: string): string => `\n  fn gs_bicubic_interpolate(p: mat4x4<${dataType}>, x: f32, y: f32) -> ${dataType} {\n    var v: vec4<f32>;\n    var coeffs = gs_get_cubic_coeffs(x);\n    for (var i = 0; i < 4; i++) {\n      v[i] = coeffs[0] * p[i][0] + coeffs[1] * p[i][1] + coeffs[2] * p[i][2] + coeffs[3] * p[i][3];\n    }\n    coeffs = gs_get_cubic_coeffs(y);\n    let pixel = ${dataType}(coeffs[0] * v[0] + coeffs[1] * v[1] + coeffs[2] * v[2] + coeffs[3] * v[3]);\n    return pixel;\n  }\n`;\n\nconst gsDenormalize = (attributes: GridSampeAttributes): string => `\n  fn gs_denormalize(n: f32, length: i32) -> f32 {\n    ${\n      attributes.alignCorners === 0\n        ? `\n    // alignCorners: false => [-1, 1] to [-0.5, length - 0.5]\n    return ((n + 1.0) * f32(length) - 1.0) / 2.0;\n    `\n        : `\n    // alignCorners: true => [-1, 1] to [0, length - 1]\n    return (n + 1.0) / 2.0 * (f32(length - 1));\n    `\n    }\n  }\n`;\n\nconst gsReflect = (attributes: GridSampeAttributes): string => `\n  ${\n    attributes.paddingMode === 'reflection'\n      ? `\n      fn gs_reflect(x: i32, x_min: f32, x_max: f32) -> u32 {\n        var dx = 0.0;\n        var fx = f32(x);\n        let range = x_max - x_min;\n        if (fx < x_min) {\n          dx = x_min - fx;\n          let n = u32(dx / range);\n          let r = dx - f32(n) * range;\n          if (n % 2 == 0) {\n            fx = x_min + r;\n          } else {\n            fx = x_max - r;\n          }\n        } else if (fx > x_max) {\n          dx = fx - x_max;\n          let n = u32(dx / range);\n          let r = dx - f32(n) * range;\n          if (n % 2 == 0) {\n            fx = x_max - r;\n          } else {\n            fx = x_min + r;\n          }\n        }\n        return u32(fx);\n      }`\n      : ''\n  }\n`;\n\nconst pixelAtGrid = (input: IndicesHelper, dataType: string, attributes: GridSampeAttributes): string =>\n  `\n  fn pixel_at_grid(r: i32, c: i32, H: i32, W: i32, batch: u32, channel: u32, border: vec4<f32>) -> ${dataType} {\n     var pixel = ${dataType}(0);\n     var indices = vec4<u32>(0);\n     indices[${idxN}] = batch;\n     indices[${idxC}] = channel;` +\n  (() => {\n    switch (attributes.paddingMode) {\n      case 'zeros':\n        return `\n          if (r >= 0 && r < H && c >=0 && c < W) {\n            indices[${idxH}] = u32(r);\n            indices[${idxW}] = u32(c);\n          } else {\n            return ${dataType}(0);\n          }\n        `;\n      case 'border':\n        return `\n          indices[${idxH}] = u32(clamp(r, 0, H - 1));\n          indices[${idxW}] = u32(clamp(c, 0, W - 1));\n        `;\n      case 'reflection':\n        return `\n          indices[${idxH}] = gs_reflect(r, border[1], border[3]);\n          indices[${idxW}] = gs_reflect(c, border[0], border[2]);\n        `;\n      default:\n        throw new Error(`padding mode ${attributes.paddingMode} is not supported`);\n    }\n  })() +\n  `\n    return ${input.getByIndices('indices')};\n  }\n`;\n\nconst computePixel = (output: IndicesHelper, dataType: string, attributes: GridSampeAttributes): string =>\n  (() => {\n    switch (attributes.mode) {\n      case 'nearest':\n        return `\n          let result = pixel_at_grid(i32(round(y)), i32(round(x)), H_in, W_in, indices[${idxN}], indices[${idxC}], border);\n        `;\n      case 'bilinear':\n        return `\n          let x1 = i32(floor(x));\n          let y1 = i32(floor(y));\n          let x2 = x1 + 1;\n          let y2 = y1 + 1;\n\n          let p11 = pixel_at_grid(y1, x1, H_in, W_in, indices[${idxN}], indices[${idxC}], border);\n          let p12 = pixel_at_grid(y1, x2, H_in, W_in, indices[${idxN}], indices[${idxC}], border);\n          let p21 = pixel_at_grid(y2, x1, H_in, W_in, indices[${idxN}], indices[${idxC}], border);\n          let p22 = pixel_at_grid(y2, x2, H_in, W_in, indices[${idxN}], indices[${idxC}], border);\n\n          let dx2 = ${dataType}(f32(x2) - x);\n          let dx1 = ${dataType}(x - f32(x1));\n          let dy2 = ${dataType}(f32(y2) - y);\n          let dy1 = ${dataType}(y - f32(y1));\n          let result = dy2 * (dx2 * p11 + dx1 * p12) + dy1 * (dx2 * p21 + dx1 * p22);\n        `;\n      case 'bicubic':\n        return `\n          let x0 = i32(floor(x)) - 1;\n          let y0 = i32(floor(y)) - 1;\n          var p: mat4x4<${dataType}>;\n          for (var h = 0; h < 4; h++) {\n            for (var w = 0; w < 4; w++) {\n              p[h][w] = pixel_at_grid(h + y0, w + x0, H_in, W_in, indices[${idxN}], indices[${idxC}], border);\n            }\n          }\n\n          let dx = x - f32(x0 + 1);\n          let dy = y - f32(y0 + 1);\n          let result = gs_bicubic_interpolate(p, dx, dy);\n        `;\n      default:\n        throw new Error(`mode ${attributes.mode} is not supported`);\n    }\n  })() + `${output.setByOffset('global_idx', 'result')}`;\n\nconst createGridSampleProgramInfo = (inputs: readonly TensorView[], attributes: GridSampeAttributes): ProgramInfo => {\n  const x = inputVariable('x', inputs[0].dataType, inputs[0].dims.length);\n  // discard last dimension for using vec2 to access grid data\n  const gridShape = [inputs[1].dims[0], inputs[1].dims[1], inputs[1].dims[2]];\n  const grid = inputVariable('grid', inputs[1].dataType, gridShape.length, 2);\n  let outputShape = [inputs[0].dims[0], inputs[0].dims[1], inputs[1].dims[1], inputs[1].dims[2]];\n  if (attributes.format === 'NHWC') {\n    outputShape = [inputs[0].dims[0], inputs[1].dims[1], inputs[1].dims[2], inputs[0].dims[3]];\n    [idxN, idxC, idxH, idxW] = [0, 3, 1, 2];\n  }\n  const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n  const dataType = x.type.value;\n  const outputSize = ShapeUtil.size(outputShape);\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    ...createTensorShapeVariables(inputs[0].dims, gridShape, outputShape),\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(x, grid, output)}\n  ${gsGetCubicCoeffs}\n  ${gsBicubicInterpolate(dataType)}\n  ${gsDenormalize(attributes)}\n  ${gsReflect(attributes)}\n  ${pixelAtGrid(x, dataType, attributes)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n      let H_in = i32(uniforms.x_shape[${idxH}]);\n      let W_in = i32(uniforms.x_shape[${idxW}]);\n\n      ${\n        attributes.alignCorners === 0\n          ? `\n      let x_min = -0.5;\n      let x_max = f32(W_in) - 0.5;\n      let y_min = -0.5;\n      let y_max = f32(H_in) - 0.5;\n      `\n          : `\n      let x_min = 0.0;\n      let x_max = f32(W_in) - 1.0;\n      let y_min = 0.0;\n      let y_max = f32(H_in) - 1.0;\n      `\n      };\n      let border = vec4<f32>(x_min, y_min, x_max, y_max);\n\n      let indices = ${output.offsetToIndices('global_idx')};\n      var grid_indices = vec3<u32>(indices[${idxN}], indices[${idxH}], indices[${idxW}]);\n      let nxy = ${grid.getByIndices('grid_indices')};\n      var x = gs_denormalize(f32(nxy[0]), W_in);\n      var y = gs_denormalize(f32(nxy[1]), H_in);\n\n      ${computePixel(output, dataType, attributes)}\n  }`;\n\n  return {\n    name: 'GridSample',\n    shaderCache: { hint: `${attributes.cacheKey}`, inputDependencies: ['type', 'type'] },\n    getRunData: (inputs) => {\n      const outputSize = ShapeUtil.size(outputShape);\n      return {\n        outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n        dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n        programUniforms,\n      };\n    },\n    getShaderSource,\n  };\n};\n\nexport const gridSample = (context: ComputeContext, attributes: GridSampeAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createGridSampleProgramInfo(context.inputs, attributes));\n};\n\nexport const parseGridSampleAttributes = (attributes: Record<string, unknown>): GridSampeAttributes =>\n  createAttributeWithCacheKey({\n    alignCorners: attributes.align_corners as number,\n    mode: attributes.mode as Mode,\n    paddingMode: attributes.padding_mode as PaddingMode,\n    format: attributes.format as Format,\n  });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, GpuDataType, ProgramUniform } from '../types';\n\nimport {\n  applyAttention,\n  AttentionAttrs,\n  AttentionMaskType,\n  AttentionParameters,\n  AttentionQkvFormat,\n} from './attention';\nimport { inputVariable, outputVariable, ShaderHelper, UniformsArrayType } from './common';\nimport { createTransposeProgramInfo, TransposeAttributes } from './transpose';\n\nconst getInput = (inputs: readonly TensorView[], i: number) =>\n  inputs.length > i && inputs[i].dims.length > 0 ? inputs[i] : undefined;\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: AttentionAttrs): AttentionParameters => {\n  const query = inputs[0];\n  const key = getInput(inputs, 1);\n  const value = getInput(inputs, 2);\n  const bias = getInput(inputs, 3);\n  const keyPaddingMask = getInput(inputs, 4);\n  const attentionBias = getInput(inputs, 5);\n  const pastKey = getInput(inputs, 6);\n  const pastValue = getInput(inputs, 7);\n\n  // ---------------------------------------------------------------\n  // Notations:\n  //    B: batch_size\n  //    N: num_heads\n  //    H: head_size of Q and K\n  //    H_v: head_size of V\n  //    D: hidden_size for Q and K, where D = N * H\n  //    D_v: hidden_size of V, where D_v = N * H_v\n  //    S: q_sequence_length\n  //    P: past_sequence_length of kv cache\n  //    L: kv_sequence_length\n  //    T: total_sequence_length = P + L\n  //    M: max_sequence_length of kv cache when past and present share buffer\n  // ---------------------------------------------------------------\n  // MultiHeadAttention inputs:\n  // ---------------------------------------------------------------\n  //  Q_K_V_BSNH - no packing:\n  //     query            (Q)       : (B, S, D)\n  //     key              (K)       : (B, L, D)\n  //     value            (V)       : (B, L, D_v)\n  //  Q_K_V_BSNH_BNSH_BNSH - cross attention (kv cache is not used, L == T, D == D_v):\n  //     query            (Q)       : (B, S, D)\n  //     key              (K)       : (B, N, L, H)\n  //     value            (V)       : (B, N, L, H_v)\n  //  Q_KV_BSNH_BSN2H - packed kv (kv cache is not used, bias is not allowed for packed kv):\n  //     query            (Q)       : (B, S, D)\n  //     key              (K/V)     : (B, L, N, 2, H)\n  //     value                      : None\n  //  QKV_BSN3H - packed qkv (kv cache is not used, S == L, D == D_v):\n  //     query            (Q/K/V)   : (B, S, N, 3, H)\n  //     key                        : None\n  //     value                      : None\n  //\n  //  Other inputs:\n  //     bias             (Q/K/V)   : None or (D + D + D_v)\n  //     key_padding_mask (K/V)     : (B) or (3 * B + 2) or (B, T) or (B, S, T)\n  //     attention_bias             : None or (B, N, S, T), (1, N, S, T), (B, 1, S, T) or (1, 1, S, T)\n  //     past_key                   : (B, N, P, H) or None. Past state is only allowed for Q_K_V_BSNH.\n  //     past_value                 : (B, N, P, H) or None. Past state is only allowed for Q_K_V_BSNH.\n  //\n  //  Not Supported:\n  //     key_padding_mask, packed kv, packed qkv, and broadcast for attention_bias.\n\n  if (query.dims.length !== 3 && query.dims.length !== 5) {\n    throw new Error('Input query is expected to have 3 or 5 dimensions');\n  }\n\n  const batchSize = query.dims[0];\n  const sequenceLength = query.dims[1];\n  const hiddenSize = query.dims.length === 3 ? query.dims[2] : attributes.numHeads * query.dims[4];\n  let kvSequenceLength = sequenceLength;\n\n  let pastSequenceLength = 0;\n  let maxSequenceLength = 0;\n  const headSize = Math.floor(hiddenSize / attributes.numHeads);\n  if (pastKey && pastValue && ShapeUtil.size(pastKey.dims) && ShapeUtil.size(pastValue.dims)) {\n    if (pastKey.dims.length !== 4) {\n      throw new Error('Input \"past_key\" is expected to have 4 dimensions');\n    }\n    if (pastKey.dims[0] !== batchSize || pastKey.dims[1] !== attributes.numHeads || pastKey.dims[3] !== headSize) {\n      throw new Error('Input \"past_key\" shape (batch_size, num_heads, past_sequence_length, head_size)');\n    }\n    if (\n      pastValue.dims[0] !== batchSize ||\n      pastValue.dims[1] !== attributes.numHeads ||\n      pastValue.dims[3] !== headSize\n    ) {\n      throw new Error('Input \"past_value\" shape (batch_size, num_heads, past_sequence_length, head_size)');\n    }\n    if (pastKey.dims[2] !== pastValue.dims[2]) {\n      throw new Error('Input \"past_key\" and \"past_value\" shall have same dim 2 (past_sequence_length)');\n    }\n    if (pastValue.dims.length !== 4) {\n      throw new Error('Input \"past_value\" is expected to have 4 dimensions');\n    }\n    pastSequenceLength = pastKey.dims[2];\n    maxSequenceLength = pastKey.dims[2];\n  } else if ((pastKey && ShapeUtil.size(pastKey.dims)) || (pastValue && ShapeUtil.size(pastValue.dims))) {\n    throw new Error('Input \"past_key\" and \"past_value\" shall be both present or both absent');\n  }\n\n  let qkvFormat: AttentionQkvFormat;\n  if (key && ShapeUtil.size(key.dims) > 0) {\n    if (query.dims.length !== 3) {\n      throw new Error('Input \"query\" is expected to have 3 dimensions when key is given');\n    }\n    if (key.dims.length < 3 || key.dims.length > 5) {\n      throw new Error('Input \"key\" is expected to have 3, 4, or 5 dimensions');\n    }\n    if (query.dims[0] !== key.dims[0]) {\n      throw new Error('Input \"query\" and \"key\" shall have same dim 0 (batch size)');\n    }\n\n    if (key.dims.length === 3) {\n      if (key.dims[2] !== query.dims[2]) {\n        throw new Error('Input \"query\" and \"key\" shall have same dim 2 (hidden_size)');\n      }\n      qkvFormat = AttentionQkvFormat.qkvBSNH;\n      kvSequenceLength = key.dims[1];\n    } else if (key.dims.length === 5) {\n      if (key.dims[2] !== attributes.numHeads || key.dims[3] !== 2 || key.dims[4] !== headSize) {\n        throw new Error('Expect \"key\" shape (batch_size, kv_sequence_length, num_heads, 2, head_size) for packed kv');\n      }\n      if (value) {\n        throw new Error('Expect \"value\" be none when \"key\" has packed kv format.');\n      }\n      qkvFormat = AttentionQkvFormat.qKvBSNHxBSN2H;\n      kvSequenceLength = key.dims[1];\n    } else {\n      // key_dims.size() == 4 (cross-attention with past_key)\n      if (key.dims[1] !== attributes.numHeads || key.dims[3] !== headSize) {\n        throw new Error('Expect \"key\" shape (batch_size, num_heads, kv_sequence_length, head_size) for past_key');\n      }\n\n      qkvFormat = AttentionQkvFormat.unknown; // Q_K_V_BSNH_BNSH_BNSH\n      kvSequenceLength = key.dims[2];\n    }\n  } else {\n    // packed QKV\n    if (query.dims.length !== 5) {\n      throw new Error('Input \"query\" is expected to have 5 dimensions when key is empty');\n    }\n    if (query.dims[2] !== attributes.numHeads || query.dims[3] !== 3) {\n      throw new Error('Expect \"query\" shape (batch_size, kv_sequence_length, num_heads, 3, head_size) for packed kv');\n    }\n\n    qkvFormat = AttentionQkvFormat.qkvBSN3H;\n  }\n\n  if (bias && ShapeUtil.size(bias.dims) > 0) {\n    if (bias.dims.length !== 1) {\n      throw new Error('Input \"bias\" is expected to have 1 dimension');\n    }\n\n    if (key) {\n      if (key.dims.length === 5 && key.dims[3] === 2) {\n        throw new Error('bias is not allowed for packed kv.');\n      }\n    }\n  }\n\n  const totalSequenceLength = pastSequenceLength + kvSequenceLength;\n\n  let maskType: AttentionMaskType = AttentionMaskType.none;\n  if (keyPaddingMask && ShapeUtil.size(keyPaddingMask.dims) > 0) {\n    maskType = AttentionMaskType.maskUnknown;\n    const maskDims = keyPaddingMask.dims;\n    if (maskDims.length === 1) {\n      if (maskDims[0] === batchSize) {\n        maskType = AttentionMaskType.mask1dKeySeqLen;\n      } else if (maskDims[0] === 3 * batchSize + 2) {\n        maskType = AttentionMaskType.mask1DKeySeqLenStart;\n      }\n    } else if (maskDims.length === 2 && maskDims[0] === batchSize && maskDims[1] === totalSequenceLength) {\n      maskType = AttentionMaskType.mask2dKeyPadding;\n    }\n    if (maskType === AttentionMaskType.maskUnknown) {\n      throw new Error('Input \"key_padding_mask\" shape shall be (batch_size) or (batch_size, total_sequence_length)');\n    }\n    throw new Error('Mask not supported');\n  }\n\n  let passPastInKv = false;\n  let vHiddenSize = hiddenSize;\n  if (value && ShapeUtil.size(value.dims) > 0) {\n    if (value.dims.length !== 3 && value.dims.length !== 4) {\n      throw new Error('Input \"value\" is expected to have 3 or 4 dimensions');\n    }\n\n    if (query.dims[0] !== value.dims[0]) {\n      throw new Error('Input \"query\" and \"value\" shall have same dim 0 (batch_size)');\n    }\n\n    if (value.dims.length === 3) {\n      if (kvSequenceLength !== value.dims[1]) {\n        throw new Error('Input \"key\" and \"value\" shall have the same dim 1 (kv_sequence_length)');\n      }\n      vHiddenSize = value.dims[2];\n    } else {\n      // Q_K_V_BSNH_BNSH_BNSH\n      if (kvSequenceLength !== value.dims[2]) {\n        throw new Error('Input \"key\" and \"value\" shall have the same dim 2 (kv_sequence_length)');\n      }\n      vHiddenSize = value.dims[1] * value.dims[3];\n      passPastInKv = true;\n    }\n  }\n\n  const broadcastResPosBias = false;\n\n  if (keyPaddingMask && ShapeUtil.size(keyPaddingMask.dims) > 0) {\n    throw new Error('Key padding mask is not supported');\n  }\n\n  if (attentionBias && ShapeUtil.size(attentionBias.dims) > 0) {\n    if (attentionBias.dims.length !== 4) {\n      throw new Error('Input \"attention_bias\" is expected to have 4 dimensions');\n    }\n\n    // TODO: support broadcasting the first and second dimensions of attention_bias.\n    if (\n      attentionBias.dims[0] !== batchSize ||\n      attentionBias.dims[1] !== attributes.numHeads ||\n      attentionBias.dims[2] !== sequenceLength ||\n      attentionBias.dims[3] !== totalSequenceLength\n    ) {\n      throw new Error('Expect \"attention_bias\" shape (batch_size, num_heads, sequence_length, total_sequence_length)');\n    }\n  }\n\n  return {\n    batchSize,\n    sequenceLength,\n    pastSequenceLength,\n    kvSequenceLength,\n    totalSequenceLength,\n    maxSequenceLength,\n    inputHiddenSize: 0,\n    hiddenSize,\n    vHiddenSize,\n    headSize,\n    vHeadSize: Math.floor(vHiddenSize / attributes.numHeads),\n    numHeads: attributes.numHeads,\n    isUnidirectional: false,\n    pastPresentShareBuffer: false,\n    maskFilterValue: attributes.maskFilterValue,\n    maskType,\n    scale: attributes.scale,\n    broadcastResPosBias,\n    passPastInKv,\n    qkvFormat,\n  };\n};\n\nexport const parseMultiHeadAttentionAttributes = (attributes: AttentionAttrs): AttentionAttrs =>\n  createAttributeWithCacheKey({ ...attributes });\n\nconst weightTransposeAttribute: TransposeAttributes = createAttributeWithCacheKey({ perm: [0, 2, 1, 3] });\n\nconst addBiasTranspose = (\n  context: ComputeContext,\n  qkv: TensorView,\n  bias: TensorView,\n  batchSize: number,\n  sequenceLength: number,\n  hiddenSize: number,\n  biasOffset: number,\n) => {\n  const outputShape = [batchSize, sequenceLength, hiddenSize];\n  const outputSize = ShapeUtil.size(outputShape);\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.uint32, data: biasOffset },\n    { type: DataType.uint32, data: hiddenSize },\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const output = outputVariable('qkv_with_bias', qkv.dataType, outputShape);\n    const qkvInput = inputVariable('qkv', qkv.dataType, outputShape);\n    const biasInput = inputVariable('bias', bias.dataType, outputShape);\n\n    const uniforms: UniformsArrayType = [\n      { name: 'output_size', type: 'u32' },\n      { name: 'bias_offset', type: 'u32' },\n      { name: 'hidden_size', type: 'u32' },\n    ];\n    return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(qkvInput, biasInput, output)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    let bias_offset_idx = (global_idx % uniforms.hidden_size) + uniforms.bias_offset;\n\n    qkv_with_bias[global_idx] = qkv[global_idx] + bias[bias_offset_idx];\n  }`;\n  };\n\n  return context.compute(\n    {\n      name: 'MultiHeadAttentionAddBias',\n      shaderCache: { inputDependencies: ['type', 'type'] },\n      getRunData: () => ({\n        outputs: [{ dims: outputShape, dataType: qkv.dataType, gpuDataType: GpuDataType.default }],\n        dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n        programUniforms,\n      }),\n      getShaderSource,\n    },\n    { inputs: [qkv, bias], outputs: [-1] },\n  )[0];\n};\n\nexport const maybeTransposeToBNSHAndAddBias = (\n  context: ComputeContext,\n  batchSize: number,\n  numHeads: number,\n  sequenceLength: number,\n  headSize: number,\n  input: TensorView,\n  bias?: TensorView,\n  biasOffset?: number,\n) => {\n  // const newDims = [];\n\n  let reshapedInput = input;\n  if (!(bias && ShapeUtil.size(bias.dims) > 0)) {\n    if (input.dims.length === 3) {\n      reshapedInput = input.reshape([batchSize, sequenceLength, numHeads, headSize]);\n    }\n    if (numHeads === 1 || sequenceLength === 1) {\n      return reshapedInput;\n    }\n    return context.compute(createTransposeProgramInfo(reshapedInput, weightTransposeAttribute.perm), {\n      inputs: [reshapedInput],\n      outputs: [-1],\n    })[0];\n  } else {\n    if (sequenceLength === 1) {\n      throw new Error('AddBiasReshape is not implemented. Please export your model with packed QKV or KV');\n    } else {\n      reshapedInput = addBiasTranspose(\n        context,\n        input,\n        bias,\n        batchSize,\n        sequenceLength,\n        numHeads * headSize,\n        biasOffset!,\n      );\n      reshapedInput = reshapedInput.reshape([batchSize, sequenceLength, numHeads, headSize]);\n      if (numHeads === 1 || sequenceLength === 1) {\n        return reshapedInput;\n      }\n      return context.compute(createTransposeProgramInfo(reshapedInput, weightTransposeAttribute.perm), {\n        inputs: [reshapedInput],\n        outputs: [-1],\n      })[0];\n    }\n  }\n};\n\nexport const multiHeadAttention = (context: ComputeContext, attributes: AttentionAttrs): void => {\n  const params = validateInputs(context.inputs, attributes);\n  const query = context.inputs[0];\n  const key = getInput(context.inputs, 1);\n  const value = getInput(context.inputs, 2);\n  const bias = getInput(context.inputs, 3);\n  const keyPaddingMask = getInput(context.inputs, 4);\n  const attentionBias = getInput(context.inputs, 5);\n  const pastKey = getInput(context.inputs, 6);\n  const pastValue = getInput(context.inputs, 7);\n  if (query.dims.length === 5) {\n    throw new Error('Packed QKV is not implemented');\n  }\n\n  if (key?.dims.length === 5) {\n    throw new Error('Packed KV is not implemented');\n  }\n\n  // applyAttention expects BNSH inputs\n  const kvBNSH = key && value && key.dims.length === 4 && value.dims.length === 4;\n\n  const Q = maybeTransposeToBNSHAndAddBias(\n    context,\n    params.batchSize,\n    params.numHeads,\n    params.sequenceLength,\n    params.headSize,\n    query,\n    bias,\n    0,\n  );\n\n  if (kvBNSH) {\n    return applyAttention(context, Q, key, value, keyPaddingMask, undefined, pastKey, pastValue, attentionBias, params);\n  }\n  if (!key || !value) {\n    throw new Error('key and value must be provided');\n  }\n  const K = maybeTransposeToBNSHAndAddBias(\n    context,\n    params.batchSize,\n    params.numHeads,\n    params.kvSequenceLength,\n    params.headSize,\n    key,\n    bias,\n    params.hiddenSize,\n  );\n\n  const V = maybeTransposeToBNSHAndAddBias(\n    context,\n    params.batchSize,\n    params.numHeads,\n    params.kvSequenceLength,\n    params.vHeadSize,\n    value,\n    bias,\n    2 * params.hiddenSize,\n  );\n\n  applyAttention(context, Q, K, V, keyPaddingMask, undefined, pastKey, pastValue, attentionBias, params);\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramUniform, TensorInfo } from '../types';\n\nimport {\n  createTensorShapeVariables,\n  getElementAt,\n  IndicesHelper,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n} from './common';\n\nexport interface SplitAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n  readonly numOutputs: number;\n  readonly splitSizes: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('too few inputs');\n  }\n};\n\nconst createSplitAttributesFromInputs = (\n  inputs: readonly TensorView[],\n  attributes: SplitAttributes,\n): SplitAttributes => {\n  const splitSizes: number[] = [];\n  let numOutputs: number = attributes.numOutputs;\n  if (inputs[1].dims[0] > 0) {\n    inputs[1].getBigInt64Array().forEach((v) => splitSizes.push(Number(v)));\n    numOutputs = splitSizes.length;\n  }\n  return createAttributeWithCacheKey({ numOutputs, axis: attributes.axis, splitSizes });\n};\n\nconst calculateOutputIndexImpl = (numberOfTensors: number): string => `\nfn calculateOutputIndex(index: u32) -> u32 {\n    for (var i: u32 = 0u; i < ${numberOfTensors}u; i += 1u ) {\n    if (index < ${getElementAt('uniforms.size_in_split_axis', 'i', numberOfTensors)}) {\n        return i;\n    }\n    }\n    return ${numberOfTensors}u;\n}`;\nconst writeBufferDataImpl = (outputs: readonly IndicesHelper[]) => {\n  const numberOfTensors = outputs.length;\n  const codeLines: string[] = [];\n  for (let i = 0; i < numberOfTensors; ++i) {\n    const returnSnippet = outputs[i].setByIndices('indices', 'input[global_idx]');\n    if (numberOfTensors === 1) {\n      codeLines.push(returnSnippet);\n    } else if (i === 0) {\n      codeLines.push(`if (output_number == ${i}u) { ${returnSnippet} }`);\n    } else if (i === numberOfTensors - 1) {\n      codeLines.push(`else { ${returnSnippet} }`);\n    } else {\n      codeLines.push(`else if (output_number == ${i}) { ${returnSnippet} }`);\n    }\n  }\n  return `\n      fn writeBufferData(output_number: u32, indices: ${outputs[0].type.indices}, global_idx: u32) {\n        ${codeLines.join('\\n')}\n      }`;\n};\n\nexport const createSplitProgramInfo = (inputs: readonly TensorView[], attributes: SplitAttributes): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const inputSize = ShapeUtil.size(inputShape);\n  const dataType = inputs[0].dataType;\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, inputShape.length);\n  const outputs = new Array<IndicesHelper>(attributes.numOutputs);\n  const input = inputVariable('input', dataType, inputShape.length);\n  const sizeInSplitAxis = new Array<number>(attributes.numOutputs);\n  const outputsTensorInfo: TensorInfo[] = [];\n  const outputShapes: number[][] = [];\n  let previousSum = 0;\n  const programUniforms: ProgramUniform[] = [{ type: DataType.uint32, data: inputSize }];\n  for (let i = 0; i < attributes.numOutputs; i++) {\n    previousSum += attributes.splitSizes[i];\n    sizeInSplitAxis[i] = previousSum;\n    const outputShape = inputShape.slice();\n    outputShape[axis] = attributes.splitSizes[i];\n    outputShapes.push(outputShape);\n    outputs[i] = outputVariable(`output${i}`, dataType, outputShape.length);\n    outputsTensorInfo.push({ dims: outputShapes[i], dataType: inputs[0].dataType });\n  }\n  programUniforms.push(\n    { type: DataType.uint32, data: sizeInSplitAxis },\n    ...createTensorShapeVariables(inputShape, ...outputShapes),\n  );\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n  ${shaderHelper\n    .registerUniform('input_size', 'u32')\n    .registerUniform('size_in_split_axis', 'u32', sizeInSplitAxis.length)\n    .declareVariables(input, ...outputs)}\n  ${calculateOutputIndexImpl(sizeInSplitAxis.length)}\n  ${writeBufferDataImpl(outputs)}\n\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.input_size')}\n\n    var indices = ${input.offsetToIndices('global_idx')};\n    var index = ${input.indicesGet('indices', axis)};\n    let output_number = calculateOutputIndex(index);\n    if (output_number != 0) {\n      index -= ${getElementAt('uniforms.size_in_split_axis', 'output_number - 1u', sizeInSplitAxis.length)};\n      ${input.indicesSet('indices', axis, 'index')};\n    }\n    writeBufferData(output_number, indices, global_idx);\n  }`;\n  return {\n    name: 'Split',\n    shaderCache: { hint: attributes.cacheKey, inputDependencies: ['rank'] },\n    getShaderSource,\n    getRunData: () => ({\n      outputs: outputsTensorInfo,\n      dispatchGroup: { x: Math.ceil(inputSize / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n  };\n};\n\nexport const split = (context: ComputeContext, attributes: SplitAttributes): void => {\n  validateInputs(context.inputs);\n  const updatedAttributes =\n    context.inputs.length === 1 ? attributes : createSplitAttributesFromInputs(context.inputs, attributes);\n  context.compute(createSplitProgramInfo(context.inputs, updatedAttributes), { inputs: [0] });\n};\n\nexport const parseSplitAttributes = (attributes: Record<string, unknown>): SplitAttributes => {\n  const axis = attributes.axis as number;\n  const splitSizes: number[] = attributes.splitSizes as number[];\n  const numOutputs = (attributes.numOutputs as number) < 0 ? splitSizes.length : (attributes.numOutputs as number);\n  if (numOutputs !== splitSizes.length) {\n    throw new Error('numOutputs and splitSizes length must be equal');\n  }\n  return createAttributeWithCacheKey({ axis, numOutputs, splitSizes });\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramUniform } from '../types';\n\nimport { createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper, WORKGROUP_SIZE } from './common';\n\nexport interface RotaryEmbeddingAttributes {\n  readonly interleaved: boolean;\n  readonly numHeads: number;\n  readonly rotaryEmbeddingDim: number;\n  readonly scale: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: RotaryEmbeddingAttributes): void => {\n  const [input, positionIds, cosCache, sinCache] = inputs;\n  const { numHeads, rotaryEmbeddingDim } = attributes;\n\n  if (input.dims.length !== 3 && input.dims.length !== 4) {\n    throw new Error(`Input 'x' is expected to have 3 or 4 dimensions, got ${input.dims.length}`);\n  }\n  if (\n    !ShapeUtil.areEqual(positionIds.dims, []) &&\n    !ShapeUtil.areEqual(positionIds.dims, [1]) &&\n    positionIds.dims.length !== 2\n  ) {\n    throw new Error(`Input 'position_ids' is expected to have 0, 1, or 2 dimensions, got ${positionIds.dims.length}`);\n  }\n  if (cosCache.dims.length !== 2) {\n    throw new Error(`Input 'cos_cache' is expected to have 2 dimensions, got ${cosCache.dims.length}`);\n  }\n  if (sinCache.dims.length !== 2) {\n    throw new Error(`Input 'sin_cache' is expected to have 2 dimensions, got ${sinCache.dims.length}`);\n  }\n  if (!ShapeUtil.areEqual(cosCache.dims, sinCache.dims)) {\n    throw new Error(\"Inputs 'cos_cache' and 'sin_cache' are expected to have the same shape\");\n  }\n\n  if (rotaryEmbeddingDim > 0 && numHeads === 0) {\n    throw new Error('num_heads must be provided if rotary_embedding_dim is specified');\n  }\n\n  const batchSize = input.dims[0];\n  const sequenceLength = input.dims[input.dims.length - 2];\n  const maxSequenceLength = cosCache.dims[0];\n  const hiddenSize = ShapeUtil.sizeFromDimension(input.dims, 1) / sequenceLength;\n  const headSize = rotaryEmbeddingDim === 0 ? cosCache.dims[1] * 2 : hiddenSize / numHeads;\n  if (rotaryEmbeddingDim > headSize) {\n    throw new Error('rotary_embedding_dim must be less than or equal to head_size');\n  }\n\n  if (positionIds.dims.length === 2) {\n    if (batchSize !== positionIds.dims[0]) {\n      throw new Error(`Input 'position_ids' dimension 0 should be of size batch_size, got ${positionIds.dims[0]}`);\n    }\n    if (sequenceLength !== positionIds.dims[1]) {\n      throw new Error(`Input 'position_ids' dimension 1 should be of size sequence_length, got ${positionIds.dims[1]}`);\n    }\n  }\n\n  if (sequenceLength > maxSequenceLength) {\n    throw new Error('Updating cos_cache and sin_cache in RotaryEmbedding is not currently supported');\n  }\n\n  // Note: position_ids value validation is handled by shader-side bounds checks (defense-in-depth).\n  // We cannot validate position_ids values here because the tensor is GPU-resident \u2014 its data field\n  // is a GPU buffer ID, not a WASM heap pointer, so getBigInt64Array() would read garbage.\n\n  if (headSize / 2 !== cosCache.dims[1] && rotaryEmbeddingDim / 2 !== cosCache.dims[1]) {\n    throw new Error(\n      `Input 'cos_cache' dimension 1 should be same as head_size / 2 or rotary_embedding_dim / 2, got ${\n        cosCache.dims[1]\n      }`,\n    );\n  }\n};\n\nexport const createRotaryEmbeddingProgramInfo = (\n  inputs: readonly TensorView[],\n  attributes: RotaryEmbeddingAttributes,\n): ProgramInfo => {\n  const { interleaved, numHeads, rotaryEmbeddingDim, scale } = attributes;\n  const batchSize = inputs[0].dims[0];\n  const batchStride = ShapeUtil.sizeFromDimension(inputs[0].dims, 1);\n  const sequenceLength = inputs[0].dims[inputs[0].dims.length - 2];\n  const hiddenSize = batchStride / sequenceLength;\n  const halfRotaryEmbeddingDim = inputs[2].dims[1];\n  const headSize = rotaryEmbeddingDim === 0 ? halfRotaryEmbeddingDim * 2 : hiddenSize / numHeads;\n\n  // Rotary embeddings will be calculated in a pair-wise fashion. In accordance, use the shape\n  // [batch size, sequence length, num of heads, num of pairs to rotate + num of dims to copy]\n  // to unfold the global index in shader.\n  const globalShape = new Array<number>(\n    batchSize,\n    sequenceLength,\n    hiddenSize / headSize,\n    headSize - halfRotaryEmbeddingDim,\n  );\n  const globalStrides = ShapeUtil.computeStrides(globalShape);\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.float, data: scale },\n    { type: DataType.uint32, data: globalShape },\n    { type: DataType.uint32, data: globalStrides },\n\n    // strides for addressing the input/output tensor, in permutated order to align with the unfolded global index,\n    // i.e. BSNH\n    ...(inputs[0].dims.length === 3\n      ? new Array<ProgramUniform>({ type: DataType.uint32, data: [batchStride, hiddenSize, headSize, 1] })\n      : []),\n    ...(inputs[0].dims.length === 4\n      ? new Array<ProgramUniform>({\n          type: DataType.uint32,\n          data: [batchStride, headSize, sequenceLength * headSize, 1],\n        })\n      : []),\n\n    ...createTensorShapeVariables(inputs[0].dims, inputs[1].dims, inputs[2].dims, inputs[3].dims, inputs[0].dims),\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const input = inputVariable('input', inputs[0].dataType, inputs[0].dims.length);\n    const positionIds = inputVariable('position_ids', inputs[1].dataType, inputs[1].dims.length);\n    const cosCache = inputVariable('cos_cache', inputs[2].dataType, inputs[2].dims.length);\n    const sinCache = inputVariable('sin_cache', inputs[3].dataType, inputs[3].dims.length);\n    const output = outputVariable('output', inputs[0].dataType, inputs[0].dims.length);\n\n    shaderHelper.registerUniforms([\n      { name: 'scale', type: 'f32' },\n      { name: 'global_shape', type: 'u32', length: globalShape.length },\n      { name: 'global_strides', type: 'u32', length: globalStrides.length },\n      { name: 'input_output_strides', type: 'u32', length: globalStrides.length },\n    ]);\n\n    return `\n        ${shaderHelper.declareVariables(input, positionIds, cosCache, sinCache, output)}\n\n        ${shaderHelper.mainStart(WORKGROUP_SIZE)}\n          let half_rotary_emb_dim = uniforms.${cosCache.name}_shape[1];\n          let bsnh = global_idx / uniforms.global_strides % uniforms.global_shape;\n          let size = uniforms.global_shape[0] * uniforms.global_strides[0];\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('size')}\n\n          if (bsnh[3] < half_rotary_emb_dim) {\n            let position_ids_idx =\n                ${positionIds.broadcastedIndicesToOffset('bsnh.xy', outputVariable('', positionIds.type.tensor, 2))};\n            let position_id =\n                u32(${positionIds.getByOffset('position_ids_idx')}) + select(0, bsnh[1], position_ids_idx == 0);\n            let i = dot(bsnh, uniforms.input_output_strides) + select(0, bsnh[3], ${interleaved});\n            let j = i + select(half_rotary_emb_dim, 1, ${interleaved});\n            let re = ${input.getByOffset('i')} * ${cosCache.get('position_id', 'bsnh[3]')} -\n                ${input.getByOffset('j')} * ${sinCache.get('position_id', 'bsnh[3]')};\n            ${output.setByOffset('i', 're')}\n            let im = ${input.getByOffset('i')} * ${sinCache.get('position_id', 'bsnh[3]')} +\n                ${input.getByOffset('j')} * ${cosCache.get('position_id', 'bsnh[3]')};\n            ${output.setByOffset('j', 'im')}\n          } else {\n            let k = dot(bsnh, uniforms.input_output_strides) + half_rotary_emb_dim;\n            ${output.setByOffset('k', input.getByOffset('k'))}\n          }\n        }`;\n  };\n\n  return {\n    name: 'RotaryEmbedding',\n    shaderCache: {\n      hint: createAttributeWithCacheKey({\n        interleaved,\n      }).cacheKey,\n      inputDependencies: ['rank', 'rank', 'rank', 'rank'],\n    },\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [{ dims: inputs[0].dims, dataType: inputs[0].dataType }],\n      dispatchGroup: { x: Math.ceil(ShapeUtil.size(globalShape) / WORKGROUP_SIZE) },\n      programUniforms,\n    }),\n  };\n};\n\nexport const rotaryEmbedding = (context: ComputeContext, attributes: RotaryEmbeddingAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  context.compute(createRotaryEmbeddingProgramInfo(context.inputs, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { TensorView } from '../../tensor-view';\nimport { createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInputTensorInfoDependency, ProgramUniform } from '../types';\nimport { DataType } from '../../../wasm-common';\n\nimport { applyAttention, AttentionMaskType, AttentionParameters, AttentionQkvFormat } from './attention';\nimport { maybeTransposeToBNSHAndAddBias } from './multihead-attention';\nimport { createSplitProgramInfo, SplitAttributes } from './split';\nimport { createTransposeProgramInfo, TransposeAttributes } from './transpose';\nimport { RotaryEmbeddingAttributes, createRotaryEmbeddingProgramInfo } from './rotary-embedding';\nimport { inputVariable, outputVariable, ShaderHelper, UniformsArrayType } from './common';\nexport interface GroupQueryAttentionAttributes {\n  numHeads: number;\n  kvNumHeads: number;\n  scale: number;\n  softcap: number;\n  doRotary: number;\n  rotaryInterleaved: number;\n  smoothSoftmax: boolean;\n  localWindowSize: number;\n}\n\nexport const validateInputs = (\n  inputs: readonly TensorView[],\n  attributes: GroupQueryAttentionAttributes,\n): AttentionParameters => {\n  if (attributes.doRotary && inputs.length <= 7) {\n    throw new Error('cos_cache and sin_cache inputs are required if do_rotary is specified');\n  }\n  const query = inputs[0];\n  const key = inputs[1];\n  const value = inputs[2];\n  const pastKey = inputs[3];\n  const pastValue = inputs[4];\n  if (attributes.doRotary !== 0 && inputs.length <= 7) {\n    throw new Error('cos_cast and sin_cache are expected if do_rotary attribute is non-zero');\n  }\n  if (attributes.localWindowSize !== -1) {\n    throw new Error('Local attention is not supported');\n  }\n  if (attributes.softcap !== 0) {\n    throw new Error('Softcap is not supported');\n  }\n  if (attributes.rotaryInterleaved !== 0) {\n    throw new Error('Rotary interleaved is not supported');\n  }\n  if (attributes.smoothSoftmax) {\n    throw new Error('Smooth softmax is not supported');\n  }\n  // Abbreviation and Meanings:\n  //   B:    batch_size\n  //   S:    sequence_length (input sequence length of query)\n  //   P:    past_sequence_length (past sequence length of key or value)\n  //   L:    kv_sequence_length (input sequence length of key or value)\n  //   M:    max_sequence_length\n  //   T:    total_sequence_length = past_sequence_length + kv_sequence_length\n  //   N:    num_heads\n  //   H:    head size for Q and K, aka q_head_size or k_head_size or qk_head_size\n  //   H_v:  v_head_size\n  //   D_i:  input hidden size\n  //   D:    hidden size for Q and K (D = N * H), aka q_hidden_size or k_hidden_size or qk_hidden_size\n  //   D_v:  v_hidden_size = num_heads * v_head_size\n\n  //     past_key                   : (B, N, S*, H)\n  //     past_value                 : (B, N, S*, H)\n  // When no packing for q/k/v:\n  //     query            (Q)       : (B, S, D)\n  //     key              (K)       : (B, L, D) or (B, N, S*, H)\n  //     value            (V)       : (B, L, D_v) or (B, N, S*, H)\n  // When packed kv is used:\n  //     query            (Q)       : (B, S, D)\n  //     key              (K)       : (B, L, N, 2, H)\n  //     value            (V)       : None\n  // When packed qkv is used:\n  //     query            (Q)       : (B, L, N, 3, H) or (B, S, 3*D)\n  //     key              (K)       : None\n  //     value            (V)       : None\n\n  if (query.dims.length !== 3 && query.dims.length !== 5) {\n    throw new Error('Input query is expected to have 3 or 5 dimensions');\n  }\n\n  const dmmhaPacking = false;\n  const batchSize = query.dims[0];\n  const sequenceLength = query.dims[1];\n  let hiddenSize =\n    query.dims.length === 3 ? (dmmhaPacking ? query.dims[2] / 3 : query.dims[2]) : attributes.numHeads * query.dims[4];\n  let kvSequenceLength = sequenceLength;\n\n  let pastSequenceLength = 0;\n  const packedQKV = !key || key.dims.length === 0;\n  const headSize = !packedQKV\n    ? Math.floor(hiddenSize / attributes.numHeads)\n    : Math.floor(hiddenSize / (attributes.numHeads + 2 * attributes.kvNumHeads));\n  if (packedQKV) {\n    hiddenSize = headSize * attributes.numHeads;\n  }\n  const hasPastKey = pastKey && pastKey.dims.length !== 0;\n  const hasPastValue = pastValue && pastValue.dims.length !== 0;\n  // Currently the onnxruntime GQA specification only support key/value BNSH format.\n  const isPastkvBSNH =\n    hasPastKey &&\n    pastKey.dims.length === 4 &&\n    pastKey.dims[0] === batchSize &&\n    pastKey.dims[1] !== attributes.kvNumHeads &&\n    pastKey.dims[2] === attributes.kvNumHeads &&\n    pastKey.dims[3] === headSize;\n\n  if (isPastkvBSNH) {\n    throw new Error('BSNH pastKey/pastValue is not supported');\n  }\n  if (hasPastKey && hasPastValue) {\n    if (pastKey.dims.length !== 4) {\n      throw new Error('Input \"past_key\" is expected to have 4 dimensions');\n    }\n    if (pastValue.dims.length !== 4) {\n      throw new Error('Input \"past_value\" is expected to have 4 dimensions');\n    }\n    pastSequenceLength = pastKey.dims[2];\n  } else if (hasPastKey || hasPastValue) {\n    throw new Error('Input \"past_key\" and \"past_value\" shall be both present or both absent');\n  }\n\n  let qkvFormat: AttentionQkvFormat = AttentionQkvFormat.qkvBNSH;\n  if (key && key.dims.length > 0) {\n    if (query.dims.length !== 3) {\n      throw new Error('Input \"query\" is expected to have 3 dimensions when key is given');\n    }\n    if (key.dims.length < 3 || key.dims.length > 5) {\n      throw new Error('Input \"key\" is expected to have 3, 4, or 5 dimensions');\n    }\n    if (query.dims[0] !== key.dims[0]) {\n      throw new Error('Input \"query\" and \"key\" shall have same dim 0 (batch size)');\n    }\n\n    if (key.dims.length === 3) {\n      if (query.dims[2] % key.dims[2] !== 0) {\n        throw new Error('Dimension 2 of \"query\" should be a multiple of \"key\"');\n      }\n      kvSequenceLength = key.dims[1];\n    } else if (key.dims.length === 5) {\n      if (key.dims[2] !== attributes.numHeads || key.dims[3] !== 2 || key.dims[4] !== headSize) {\n        throw new Error('Expect \"key\" shape (batch_size, kv_sequence_length, num_heads, 2, head_size) for packed kv');\n      }\n      if (value) {\n        throw new Error('Expect \"value\" be none when \"key\" has packed kv format.');\n      }\n      kvSequenceLength = key.dims[1];\n    } else {\n      // key_dims.size() == 4 (cross-attention with past_key)\n      if (key.dims[1] !== attributes.numHeads || key.dims[3] !== headSize) {\n        throw new Error('Expect \"key\" shape (batch_size, num_heads, kv_sequence_length, head_size) for past_key');\n      }\n      kvSequenceLength = key.dims[2];\n    }\n  } else {\n    // packed QKV\n    if (query.dims.length !== 3 && query.dims.length !== 5) {\n      throw new Error('Input \"query\" is expected to have 3 or 5 dimensions when key is empty');\n    }\n    if (query.dims.length === 5 && (query.dims[2] !== attributes.numHeads || query.dims[3] !== 3)) {\n      throw new Error('Expect \"query\" shape (batch_size, kv_sequence_length, num_heads, 3, head_size) for packed kv');\n    }\n\n    qkvFormat = AttentionQkvFormat.qkvBSN3H;\n  }\n\n  const maskType: AttentionMaskType = AttentionMaskType.none;\n  let passPastInKv = false;\n  let vHiddenSize = attributes.kvNumHeads ? headSize * attributes.kvNumHeads : hiddenSize;\n  if (value && value.dims.length > 0) {\n    if (value.dims.length !== 3 && value.dims.length !== 4) {\n      throw new Error('Input \"value\" is expected to have 3 or 4 dimensions');\n    }\n\n    if (query.dims[0] !== value.dims[0]) {\n      throw new Error('Input \"query\" and \"value\" shall have same dim 0 (batch_size)');\n    }\n\n    if (value.dims.length === 3) {\n      if (kvSequenceLength !== value.dims[1]) {\n        throw new Error('Input \"key\" and \"value\" shall have the same dim 1 (kv_sequence_length)');\n      }\n      vHiddenSize = value.dims[2];\n    } else {\n      if (kvSequenceLength !== value.dims[2]) {\n        throw new Error('Input \"past_key\" and \"past_value\" shall have the same dim 2 (kv_sequence_length)');\n      }\n      vHiddenSize = value.dims[1] * value.dims[3];\n      passPastInKv = true;\n    }\n  }\n  // Spec requires 1D shape (batch_size), but older model builders may add unit\n  // dimensions (e.g. [B, 1] instead of [B]). Allow shapes where each dim is 1 or batchSize.\n  const seqlLens = inputs.length > 4 ? inputs[5] : undefined;\n  if (seqlLens) {\n    if (seqlLens.dims.length === 0) {\n      throw new Error('seqlens_k must be at least 1D, got scalar.');\n    }\n    const seqlLenSize = seqlLens.dims.reduce((a, b) => a * b, 1);\n    if (seqlLenSize !== batchSize) {\n      throw new Error(`seqlens_k must have batch_size (${batchSize}) elements, got ${seqlLenSize}.`);\n    }\n    for (let i = 0; i < seqlLens.dims.length; i++) {\n      if (seqlLens.dims[i] !== 1 && seqlLens.dims[i] !== batchSize) {\n        throw new Error(\n          `seqlens_k has unexpected shape. Each dimension must be 1 or batch_size (${batchSize}), got dims[${i}] = ${seqlLens.dims[i]}.`,\n        );\n      }\n    }\n  }\n  const totalSequenceLength = -1;\n  const maxSequenceLength = -1;\n  const broadcastResPosBias = false;\n\n  return {\n    batchSize,\n    sequenceLength,\n    pastSequenceLength,\n    kvSequenceLength,\n    totalSequenceLength,\n    maxSequenceLength,\n    inputHiddenSize: 0,\n    hiddenSize,\n    vHiddenSize,\n    headSize,\n    vHeadSize: Math.floor(vHiddenSize / attributes.kvNumHeads),\n    numHeads: attributes.numHeads,\n    kvNumHeads: attributes.kvNumHeads,\n    nReps: attributes.numHeads / attributes.kvNumHeads,\n    pastPresentShareBuffer: false,\n    maskType,\n    scale: attributes.scale,\n    broadcastResPosBias,\n    passPastInKv,\n    qkvFormat,\n  };\n};\n\nconst weightTransposeAttribute: TransposeAttributes = createAttributeWithCacheKey({ perm: [0, 2, 1, 3] });\n\nconst maybeTransposeToBNSH = (context: ComputeContext, input: TensorView, params: AttentionParameters) => {\n  let reshapedInput = input;\n  const numHeads = params.kvNumHeads!;\n  if (input.dims.length === 3 && params.kvSequenceLength !== 0) {\n    reshapedInput = input.reshape([params.batchSize, params.kvSequenceLength, numHeads, params.headSize]);\n    reshapedInput = context.compute(createTransposeProgramInfo(reshapedInput, weightTransposeAttribute.perm), {\n      inputs: [reshapedInput],\n      outputs: [-1],\n    })[0];\n  }\n\n  return reshapedInput;\n};\n\nconst generatePositionIdsProgramInfo = (\n  batchSize: number,\n  sequenceLength: number,\n  seqLens: TensorView,\n  totalSeqLen: TensorView,\n) => {\n  const outputDataType = DataType.int64;\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n  const outputShape = [batchSize * sequenceLength];\n  const outputSize = batchSize * sequenceLength;\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.uint32, data: sequenceLength },\n    { type: DataType.uint32, data: batchSize },\n  ];\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const seqLensInputHelper = inputVariable('seq_lens', seqLens.dataType, seqLens.dims);\n    const totalSeqLenInputHelper = inputVariable('total_seq_lens', totalSeqLen.dataType, totalSeqLen.dims);\n    const positionIdsHelper = outputVariable('pos_ids', outputDataType, outputShape);\n\n    const uniforms: UniformsArrayType = [\n      { name: 'output_size', type: 'u32' },\n      { name: 'sequence_length', type: 'u32' },\n      { name: 'batch_size', type: 'u32' },\n    ];\n\n    return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(seqLensInputHelper, totalSeqLenInputHelper, positionIdsHelper)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n    let total_sequence_length = u32(${totalSeqLenInputHelper.getByOffset('0')});\n    let is_subsequent_prompt = uniforms.sequence_length > 1 && uniforms.sequence_length != total_sequence_length;\n    let is_first_prompt = !is_subsequent_prompt && uniforms.sequence_length == total_sequence_length;\n    let batch_idx = global_idx / uniforms.sequence_length;\n    let sequence_idx = i32(global_idx % uniforms.sequence_length);\n    var pos_id: i32 = 0;\n    let seqlen = ${seqLensInputHelper.getByOffset('batch_idx')};\n    let total_seqlen = seqlen + 1;\n    if (is_first_prompt) {\n      if (sequence_idx < total_seqlen) {\n        pos_id = sequence_idx;\n      } else {\n        pos_id = 1;\n      }\n      ${positionIdsHelper.setByOffset('global_idx', 'pos_id')}\n    } else if (is_subsequent_prompt) {\n      let past_seqlen = total_seqlen - i32(uniforms.sequence_length);\n      if (past_seqlen + sequence_idx < total_seqlen) {\n        pos_id = past_seqlen + sequence_idx;\n      } else {\n        pos_id = 1;\n      }\n      ${positionIdsHelper.setByOffset('global_idx', 'pos_id')}\n    } else if (global_idx < uniforms.batch_size) {\n      ${positionIdsHelper.setByOffset('global_idx', 'seqlen')}\n    };\n  }\n  `;\n  };\n  return {\n    name: 'GeneratePositionIds',\n    shaderCache: { hint: `${batchSize};${sequenceLength}`, inputDependencies },\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: outputDataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n\nexport const groupQueryAttention = (context: ComputeContext, attributes: GroupQueryAttentionAttributes): void => {\n  const params = validateInputs(context.inputs, attributes);\n  if (context.inputs[0].dims.length === 5) {\n    throw new Error('Packed QKV is not implemented');\n  }\n\n  if (context.inputs[1]?.dims.length === 5) {\n    throw new Error('Packed KV is not implemented');\n  }\n\n  const q = context.inputs[0];\n  const k = context.inputs[1] && context.inputs[1].dims.length > 0 ? context.inputs[1] : undefined;\n  const v = context.inputs[2] && context.inputs[2].dims.length > 0 ? context.inputs[2] : undefined;\n  const pastKey = context.inputs[3] && context.inputs[3].dims.length !== 0 ? context.inputs[3] : undefined;\n  const pastValue = context.inputs[4] && context.inputs[4].dims.length !== 0 ? context.inputs[4] : undefined;\n  const seqLens = context.inputs.length > 4 ? context.inputs[5] : undefined;\n  const totalSequenceLengthInput = context.inputs.length > 5 ? context.inputs[6] : undefined;\n  const kvNumHeads = params.kvNumHeads ? params.kvNumHeads : params.numHeads;\n\n  // TODO Remove explicit split operation and use indexing in Attention implementation to avoid overhead.\n\n  const splitAttributes: SplitAttributes = createAttributeWithCacheKey({\n    axis: 2,\n    numOutputs: 3,\n    splitSizes: [params.numHeads * params.headSize, kvNumHeads * params.headSize, kvNumHeads * params.headSize],\n  });\n  const [query, key, value] =\n    !k && !v\n      ? context.compute(createSplitProgramInfo([q], splitAttributes), { inputs: [q], outputs: [-1, -1, -1] })\n      : [q, k!, v!];\n  let qRotary: TensorView | undefined;\n  let kRotary: TensorView | undefined;\n  if (attributes.doRotary) {\n    const posIds = context.compute(\n      generatePositionIdsProgramInfo(params.batchSize, params.sequenceLength, seqLens!, totalSequenceLengthInput!),\n      { inputs: [seqLens!, totalSequenceLengthInput!], outputs: [-1] },\n    )[0];\n    const cosCache = context.inputs[7];\n    const sinCache = context.inputs[8];\n    const qRotaryEmbeddingAttributes: RotaryEmbeddingAttributes = createAttributeWithCacheKey({\n      interleaved: attributes.rotaryInterleaved !== 0,\n      numHeads: params.numHeads,\n      rotaryEmbeddingDim: 0,\n      scale: attributes.scale,\n    });\n    const inputs = [query, posIds, cosCache, sinCache];\n    const outputs = [-1];\n    qRotary = context.compute(createRotaryEmbeddingProgramInfo(inputs, qRotaryEmbeddingAttributes), {\n      inputs,\n      outputs,\n    })[0];\n    inputs.splice(0, 1, key);\n    const kRotaryEmbeddingAttributes: RotaryEmbeddingAttributes = createAttributeWithCacheKey({\n      interleaved: attributes.rotaryInterleaved !== 0,\n      numHeads: params.kvNumHeads!,\n      rotaryEmbeddingDim: 0,\n      scale: attributes.scale,\n    });\n    kRotary = context.compute(createRotaryEmbeddingProgramInfo(inputs, kRotaryEmbeddingAttributes), {\n      inputs,\n      outputs,\n    })[0];\n  }\n  const Q = maybeTransposeToBNSHAndAddBias(\n    context,\n    params.batchSize,\n    params.numHeads,\n    params.sequenceLength,\n    params.headSize,\n    attributes.doRotary ? qRotary! : query,\n    undefined,\n    0,\n  );\n  const K = maybeTransposeToBNSH(context, attributes.doRotary ? kRotary! : key, params);\n  const V = maybeTransposeToBNSH(context, value, params);\n\n  applyAttention(\n    context,\n    Q,\n    K,\n    V,\n    undefined,\n    undefined,\n    pastKey,\n    pastValue,\n    undefined,\n    params,\n    seqLens,\n    totalSequenceLengthInput,\n  );\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { ComputeContext, ProgramInputTensorInfoDependency, ProgramUniform } from '../types';\nimport { createTransposeProgramInfo } from './transpose';\n\nimport {\n  createTensorShapeVariables,\n  getMaxComponents,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  sumVector,\n  tensorTypeToWsglStorageType,\n} from './common';\n\nexport interface InstanceNormAttributes {\n  epsilon: number;\n  format: 'NHWC' | 'NCHW';\n}\n\nconst computeChannelScaleShift = (\n  context: ComputeContext,\n  input: TensorView,\n  scale: TensorView,\n  bias: TensorView,\n  n: number,\n  h: number,\n  c: number,\n  epsilon: number,\n) => {\n  const components = getMaxComponents(h);\n  const f32Type = components === 1 ? 'f32' : `vec${components}f`;\n  const wgType = components === 1 ? 'vec2f' : `mat2x${components}f`;\n  const unitsOfWork = n * c;\n  let workgroupSize = 64;\n  if (unitsOfWork === 1) {\n    workgroupSize = 256;\n  }\n  const inputShape = [n, c, h / components];\n  const outputShape = [n, c, 2];\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank', 'type', 'type'];\n  const programUniforms: ProgramUniform[] = [];\n  programUniforms.push(...createTensorShapeVariables(inputShape, outputShape));\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const x = inputVariable('x', input.dataType, 3, components);\n    const s = inputVariable('scale', scale.dataType, scale.dims);\n    const b = inputVariable('bias', bias.dataType, bias.dims);\n    const output = outputVariable('output', DataType.float, 3, 2);\n    const variables = [x, s, b, output];\n    return `\n  var<workgroup> workgroup_shared : array<${wgType}, ${workgroupSize}>;\n  const workgroup_size = ${workgroupSize}u;\n  ${shaderHelper.declareVariables(...variables)}\n  ${shaderHelper.mainStart(workgroupSize)}\n    let batch = workgroup_index / uniforms.x_shape[1];\n    let channel = workgroup_index % uniforms.x_shape[1];\n    let hight = uniforms.x_shape[2];\n    // initialize workgroup memory\n    var sum = ${f32Type}(0);\n    var squared_sum = ${f32Type}(0);\n    for (var h = local_idx; h < hight; h += workgroup_size) {\n      let value = ${f32Type}(${x.get('batch', 'channel', 'h')});\n      sum += value;\n      squared_sum += value * value;\n    }\n    workgroup_shared[local_idx] = ${wgType}(sum, squared_sum);\n    workgroupBarrier();\n\n    for (var currSize = workgroup_size >> 1;  currSize > 0; currSize = currSize >> 1) {\n      if (local_idx < currSize) {\n        workgroup_shared[local_idx] = workgroup_shared[local_idx] + workgroup_shared[local_idx + currSize];\n      }\n      workgroupBarrier();\n    }\n    if (local_idx == 0) {\n      let sum_final = ${sumVector('workgroup_shared[0][0]', components)} / f32(hight * ${components});\n      let squared_sum_final = ${sumVector('workgroup_shared[0][1]', components)} / f32(hight * ${components});\n\n      let inv_std_dev = inverseSqrt(squared_sum_final - sum_final * sum_final + f32(${epsilon}));\n      let channel_scale = inv_std_dev * f32(scale[channel]);\n      let channel_shift = f32(bias[channel]) - sum_final * channel_scale;\n      output[workgroup_index] = vec2f(channel_scale, channel_shift);\n    }\n  }`;\n  };\n\n  return context.compute(\n    {\n      name: 'InstanceNormComputeChannelScaleShift',\n      // TODO: use epsilon as uniform. Currently epsilon as uniform fails test_instancenorm_epsilon.\n      shaderCache: { hint: `${components};${epsilon};${workgroupSize}`, inputDependencies },\n      getRunData: () => ({\n        outputs: [{ dims: outputShape, dataType: DataType.float }],\n        dispatchGroup: { x: unitsOfWork },\n        programUniforms,\n      }),\n      getShaderSource,\n    },\n    { inputs: [input, scale, bias], outputs: [-1] },\n  )[0];\n};\n\nconst createInstanceNormProgramInfo = (\n  context: ComputeContext,\n  inputs: readonly TensorView[],\n  attributes: InstanceNormAttributes,\n) => {\n  const xShape = inputs[0].dims;\n  const outputShape = xShape;\n  const axis = 2;\n  const N = xShape[0];\n  const C = xShape[1];\n  const H = ShapeUtil.sizeFromDimension(xShape, axis);\n  const components = getMaxComponents(H);\n  const outputSize = ShapeUtil.size(outputShape) / components;\n  // compute channel scale and channel shift.\n  const channelScaleShift = computeChannelScaleShift(\n    context,\n    inputs[0],\n    inputs[1],\n    inputs[2],\n    N,\n    H,\n    C,\n    attributes.epsilon,\n  );\n\n  const inputShape = [N, C, H / components];\n  const scaleShape = [N, C];\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'none'];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const x = inputVariable('x', inputs[0].dataType, inputShape.length, components);\n    const scale = inputVariable('scale_shift', DataType.float, scaleShape.length, 2);\n    const output = outputVariable('output', inputs[0].dataType, inputShape.length, components);\n    const variables = [x, scale, output];\n    return `\n  ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(...variables)}\n  ${shaderHelper.mainStart()}\n  ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n      let outputIndices = ${output.offsetToIndices('global_idx')};\n      let batch = outputIndices[0];\n      let channel = outputIndices[1];\n      let scale_shift = ${scale.getByIndices('vec2<u32>(batch, channel)')};\n      let value = ${x.getByOffset('global_idx')} * ${output.type.value}(scale_shift.x) + ${output.type.value}(scale_shift.y);\n      ${output.setByOffset('global_idx', 'value')};\n  }`;\n  };\n\n  context.compute(\n    {\n      name: 'InstanceNormalization',\n      shaderCache: { hint: `${components}`, inputDependencies },\n      getRunData: () => ({\n        outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n        dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n        programUniforms: [\n          { type: DataType.uint32, data: outputSize },\n          ...createTensorShapeVariables(inputShape, scaleShape, inputShape),\n        ],\n      }),\n      getShaderSource,\n    },\n    { inputs: [inputs[0], channelScaleShift] },\n  );\n};\n\nconst createInstanceNormNHWCProgramInfo = (\n  context: ComputeContext,\n  inputs: readonly TensorView[],\n  attributes: InstanceNormAttributes,\n) => {\n  const xShape = inputs[0].dims;\n  const outputShape = xShape;\n  const N = xShape[0];\n  const C = xShape[xShape.length - 1];\n  const H = ShapeUtil.sizeFromDimension(xShape, 1) / C;\n  const components = getMaxComponents(C);\n  const outputSize = ShapeUtil.size(outputShape) / components;\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: H },\n    { type: DataType.uint32, data: Math.floor(C / components) },\n  ];\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n\n  // 1. transpose x from NHWC to NCHW\n  let needTranspose = false;\n  const transposedXPerm = [0, xShape.length - 1];\n  for (let i = 0; i < xShape.length - 2; i++) {\n    needTranspose = needTranspose || xShape[i + 1] !== 1;\n    transposedXPerm.push(i + 1);\n  }\n\n  needTranspose = needTranspose && xShape[xShape.length - 1] !== 1;\n\n  const transposedX = needTranspose\n    ? context.compute(createTransposeProgramInfo(context.inputs[0], transposedXPerm), {\n        inputs: [context.inputs[0]],\n        outputs: [-1],\n      })[0]\n    : context.inputs[0].reshape(Array.from({ length: xShape.length }, (_, i) => xShape[transposedXPerm[i]]));\n  // 2. compute channel scale and channel shift.\n  const channelScaleShift = computeChannelScaleShift(\n    context,\n    transposedX,\n    inputs[1],\n    inputs[2],\n    N,\n    H,\n    C,\n    attributes.epsilon,\n  );\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n    const scaleType = components === 1 ? 'vec2f' : `mat${components}x2f`;\n    const scaleData = (num: number) => {\n      const index = num === 0 ? 'x' : 'y';\n      const f32Type = components === 1 ? 'f32' : `vec${components}f`;\n      switch (components) {\n        case 1:\n          return `${dataType}(${f32Type}(scale.${index}))`;\n        case 2:\n          return `vec2<${dataType}>(${f32Type}(scale[0].${index}, scale[1].${index}))`;\n        case 4:\n          return `vec4<${dataType}>(${f32Type}(scale[0].${index}, scale[1].${index}, scale[2].${index}, scale[3].${index}))`;\n        default:\n          throw new Error(`Not supported compoents ${components}`);\n      }\n    };\n    const inputHelper = inputVariable('input', inputs[0].dataType, inputs[0].dims, components);\n    const outputHelper = outputVariable('output', inputs[0].dataType, outputShape, components);\n\n    return `\n  @group(0) @binding(0) var<storage, read> input : array<${inputHelper.type.storage}>;\n  @group(0) @binding(1) var<storage, read> scale_input : array<${scaleType}>;\n  @group(0) @binding(2) var<storage, read_write> output : array<${outputHelper.type.storage}>;\n  struct Uniforms {H: u32, C : u32};\n  @group(0) @binding(3) var<uniform> uniforms: Uniforms;\n\n  ${shaderHelper.mainStart()}\n    let current_image_number = global_idx / (uniforms.C * uniforms.H);\n    let current_channel_number = global_idx % uniforms.C;\n\n    let scale_offset = current_image_number * uniforms.C + current_channel_number;\n    let scale = scale_input[scale_offset];\n    output[global_idx] = fma(input[global_idx], ${scaleData(0)}, ${scaleData(1)});\n  }`;\n  };\n  context.compute(\n    {\n      name: 'InstanceNormalizationNHWC',\n      shaderCache: { hint: `${components}`, inputDependencies },\n      getRunData: () => ({\n        outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n        dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n        programUniforms,\n      }),\n      getShaderSource,\n    },\n    { inputs: [inputs[0], channelScaleShift] },\n  );\n};\n\nexport const instanceNorm = (context: ComputeContext, attributes: InstanceNormAttributes): void => {\n  if (attributes.format === 'NHWC') {\n    createInstanceNormNHWCProgramInfo(context, context.inputs, attributes);\n  } else {\n    createInstanceNormProgramInfo(context, context.inputs, attributes);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform } from '../types';\n\nimport {\n  castToF32,\n  fillVector,\n  getMaxComponents,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  sumVector,\n  tensorTypeToWsglStorageType,\n  UniformsArrayType,\n} from './common';\n\ninterface LayerNormAttributes {\n  simplified: boolean;\n  axis: number;\n  epsilon: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 2) {\n    throw new Error('layerNorm requires at least 2 inputs.');\n  }\n};\n\nconst createLayerNormProgramInfo = (\n  inputs: readonly TensorView[],\n  attributes: LayerNormAttributes,\n  outputCount: number,\n): ProgramInfo => {\n  const simplified = attributes.simplified;\n\n  const xShape = inputs[0].dims;\n  const scale = inputs[1];\n  const bias = !simplified && inputs[2];\n\n  const outputShape = xShape;\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, xShape.length);\n  const normCount = ShapeUtil.sizeToDimension(xShape, axis);\n  const normSize = ShapeUtil.sizeFromDimension(xShape, axis);\n\n  const scaleSize = ShapeUtil.size(scale.dims);\n  const biasSize = bias ? ShapeUtil.size(bias.dims) : 0;\n  if (scaleSize !== normSize || (bias && biasSize !== normSize)) {\n    throw new Error(`Size of X.shape()[axis:] == ${normSize}.\n       Size of scale and bias (if provided) must match this.\n       Got scale size of ${scaleSize} and bias size of ${biasSize}`);\n  }\n\n  const meanInvStdDevDim: number[] = [];\n  for (let i = 0; i < xShape.length; ++i) {\n    if (i < axis) {\n      meanInvStdDevDim.push(xShape[i]);\n    } else {\n      meanInvStdDevDim.push(1);\n    }\n  }\n  const components = getMaxComponents(normSize);\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['type', 'type'];\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: normCount },\n    { type: DataType.float, data: normSize },\n    { type: DataType.uint32, data: Math.floor(normSize / components) },\n    { type: DataType.float, data: attributes.epsilon },\n  ];\n  if (bias) {\n    inputDependencies.push('type');\n  }\n  const hasMeanDataOutput = outputCount > 1;\n  const hasInvStdOutput = outputCount > 2;\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n    const variables = [\n      inputVariable('x', inputs[0].dataType, inputs[0].dims, components),\n      inputVariable('scale', scale.dataType, scale.dims, components),\n    ];\n    if (bias) {\n      variables.push(inputVariable('bias', bias.dataType, bias.dims, components));\n    }\n    variables.push(outputVariable('output', inputs[0].dataType, outputShape, components));\n    if (hasMeanDataOutput) {\n      variables.push(outputVariable('mean_data_output', DataType.float, meanInvStdDevDim));\n    }\n    if (hasInvStdOutput) {\n      variables.push(outputVariable('inv_std_output', DataType.float, meanInvStdDevDim));\n    }\n\n    const uniforms: UniformsArrayType = [\n      { name: 'norm_count', type: 'u32' },\n      { name: 'norm_size', type: 'f32' },\n      { name: 'norm_size_vectorized', type: 'u32' },\n      { name: 'epsilon', type: 'f32' },\n    ];\n    return `\n  ${shaderHelper.registerUniforms(uniforms).declareVariables(...variables)}\n  ${shaderHelper.mainStart()}\n    ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.norm_count')}\n    let offset = global_idx * uniforms.norm_size_vectorized;\n    var mean_vector = ${fillVector('f32', components)};\n    var mean_square_vector = ${fillVector('f32', components)};\n\n    for (var h: u32 = 0u; h < uniforms.norm_size_vectorized; h++) {\n      let value = ${castToF32(dataType, components, 'x[h + offset]')};\n      mean_vector += value;\n      mean_square_vector += value * value;\n    }\n    let mean = ${sumVector('mean_vector', components)} / uniforms.norm_size;\n    let inv_std_dev = inverseSqrt(${sumVector('mean_square_vector', components)} / uniforms.norm_size ${\n      simplified ? '' : '- mean * mean'\n    } + uniforms.epsilon);\n\n    for (var j: u32 = 0; j < uniforms.norm_size_vectorized; j++) {\n      let f32input = ${castToF32(dataType, components, 'x[j + offset]')};\n      let f32scale = ${castToF32(dataType, components, 'scale[j]')};\n      output[j + offset] = ${variables[0].type.value}((f32input ${simplified ? '' : '- mean'}) * inv_std_dev * f32scale\n        ${bias ? `+ ${castToF32(dataType, components, 'bias[j]')}` : ''}\n      );\n    }\n\n    ${hasMeanDataOutput ? 'mean_data_output[global_idx] = mean' : ''};\n    ${hasInvStdOutput ? 'inv_std_output[global_idx] = inv_std_dev' : ''};\n  }`;\n  };\n  const outputs = [{ dims: outputShape, dataType: inputs[0].dataType }];\n  if (hasMeanDataOutput) {\n    outputs.push({ dims: meanInvStdDevDim, dataType: DataType.float });\n  }\n  if (hasInvStdOutput) {\n    outputs.push({ dims: meanInvStdDevDim, dataType: DataType.float });\n  }\n\n  return {\n    name: 'LayerNormalization',\n    shaderCache: { hint: `${components};${outputCount};${simplified}`, inputDependencies },\n    getRunData: () => ({\n      outputs,\n      dispatchGroup: { x: Math.ceil(normCount / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n\nexport const layerNorm = (context: ComputeContext, attributes: LayerNormAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createLayerNormProgramInfo(context.inputs, attributes, context.outputCount));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { TensorView } from '../../tensor-view';\nimport { BroadcastUtil, ShapeUtil } from '../../util';\nimport { ComputeContext } from '../types';\n\nimport { createNaiveMatmulProgramInfo } from './matmul-shaders';\nimport { createMatmulProgramInfo } from './3rd-party/matmul_packed_webgpu';\n\nconst validateInputs = (inputs: readonly TensorView[]): 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\nexport const matMul = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  const outputShape = BroadcastUtil.calcShape(context.inputs[0].dims, context.inputs[1].dims, true);\n  if (!outputShape) {\n    throw new Error(\"Can't use matmul on the given tensors\");\n  }\n  const N = outputShape[outputShape.length - 1];\n  const K = context.inputs[0].dims[context.inputs[0].dims.length - 1];\n  if (N < 8 && K < 8) {\n    context.compute(createNaiveMatmulProgramInfo(context.inputs, { activation: '' }, outputShape));\n  } else {\n    const M = outputShape[outputShape.length - 2];\n    const batchA = ShapeUtil.size(context.inputs[0].dims.slice(0, -2));\n    const batchB = ShapeUtil.size(context.inputs[1].dims.slice(0, -2));\n    if (batchA !== 1 && M === 1 && batchB === 1) {\n      // Optimization for batched vec-mat-mul\n      const reshapedA = context.inputs[0].reshape([1, batchA, K]);\n      const reshapedB = context.inputs[1].reshape([1, K, N]);\n      const matmulOutputShape = [1, batchA, N];\n      const matmulInputs = [reshapedA, reshapedB];\n      context.compute(createMatmulProgramInfo(matmulInputs, { activation: '' }, outputShape, matmulOutputShape), {\n        inputs: matmulInputs,\n      });\n    } else {\n      context.compute(createMatmulProgramInfo(context.inputs, { activation: '' }, outputShape));\n    }\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramUniform } from '../types';\n\nimport {\n  createTensorShapeVariables,\n  getMaxComponents,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  tensorTypeToWsglStorageType,\n} from './common';\n\n//  TODO support quantization bits not equal to 4\nexport interface MatMulNBitsAttributes extends AttributeWithCacheKey {\n  k: number;\n  n: number;\n  accuracyLevel: number;\n  bits: number;\n  blockSize: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: MatMulNBitsAttributes): void => {\n  if (inputs.length < 3 || inputs.length > 4) {\n    throw new Error('MatMulNBits requires 3 or 4 inputs');\n  }\n  const a = inputs[0];\n  const aRank = a.dims.length;\n  if (a.dims[aRank - 1] !== attributes.k) {\n    throw new Error('The last dim of input shape does not match the k value');\n  }\n  const nBlocksPerCol = Math.floor((attributes.k + attributes.blockSize - 1) / attributes.blockSize);\n  const blobSize = (attributes.blockSize / 8) * attributes.bits;\n  const b = inputs[1];\n  if (!ShapeUtil.areEqual(b.dims, [attributes.n, nBlocksPerCol, blobSize])) {\n    throw new Error('The second inputs must be 3D tensor with shape N X nBlocksPerCol X blobSize');\n  }\n  const scales = inputs[2];\n  const scalesShape = scales.dims;\n  if (ShapeUtil.size(scalesShape) !== attributes.n * nBlocksPerCol) {\n    throw new Error('scales input size error.');\n  }\n  if (inputs.length === 4) {\n    const zeroPoints = inputs[3];\n    const zeroPointsShape = zeroPoints.dims;\n\n    // This assumes zero points are packed.\n    // Unpack format (zero point has same data type and shape as scale) is not supported by webgpu.\n    const expectedZeroPointsSize =\n      attributes.n * (attributes.bits === 8 ? nBlocksPerCol : Math.floor((nBlocksPerCol * attributes.bits + 7) / 8));\n    if (ShapeUtil.size(zeroPointsShape) !== expectedZeroPointsSize) {\n      throw new Error('zeroPoints input size error.');\n    }\n  }\n};\n\nexport const createMatMulNBitsProgramInfo = (\n  inputs: readonly TensorView[],\n  attributes: MatMulNBitsAttributes,\n): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const aRank = inputShape.length;\n  const dimAOuter = inputShape[aRank - 2];\n  const dimInner = attributes.k;\n  const dimBOuter = attributes.n;\n  const batchDims = inputShape.slice(0, aRank - 2);\n  const batchSize = ShapeUtil.size(batchDims);\n  const blobSize = inputs[1].dims[2];\n  const blobSizeInWords = blobSize / 4;\n  const dataType = inputs[0].dataType;\n  const aComponents = getMaxComponents(attributes.k);\n  const bComponents = getMaxComponents(blobSizeInWords);\n  const components = getMaxComponents(dimBOuter);\n  const outputShape = batchDims.concat([dimAOuter, dimBOuter]);\n  const outputNumber = dimAOuter > 1 && (dimBOuter / components) % 2 === 0 ? 2 : 1;\n  const dispatchSize = ShapeUtil.size(outputShape) / components / outputNumber;\n\n  const workgroupSize = 64;\n\n  const programUniforms: ProgramUniform[] = [];\n  const inputShapeTemp = [batchSize, dimAOuter, dimInner / aComponents];\n  const bShape = ShapeUtil.convertShape(inputs[1].dims).slice();\n  bShape.splice(-1, 1, blobSizeInWords / bComponents);\n  programUniforms.push(...createTensorShapeVariables(inputShapeTemp));\n  programUniforms.push(...createTensorShapeVariables(bShape));\n  programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n  if (inputs.length === 4) {\n    programUniforms.push(...createTensorShapeVariables(ShapeUtil.convertShape(inputs[3].dims)));\n  }\n  const outputShapeTemp = [batchSize, dimAOuter, dimBOuter / components];\n  programUniforms.push(...createTensorShapeVariables(outputShapeTemp));\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const inputRank = inputShapeTemp.length;\n    const a = inputVariable('a', inputs[0].dataType, inputRank, aComponents);\n    const b = inputVariable('b', DataType.uint32, bShape.length, bComponents);\n    const scales = inputVariable('scales', inputs[2].dataType, inputs[2].dims.length);\n    const inputVariables = [a, b, scales];\n    const zeroPoints =\n      inputs.length === 4 ? inputVariable('zero_points', DataType.uint32, inputs[3].dims.length) : undefined;\n    if (zeroPoints) {\n      inputVariables.push(zeroPoints);\n    }\n    const outputRank = outputShapeTemp.length;\n    const output = outputVariable('output', inputs[0].dataType, outputRank, components);\n    const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n\n    const qDqDataType = (() => {\n      switch (aComponents) {\n        case 1:\n          return `array<${dataType}, 8>`;\n        case 2:\n          return `mat4x2<${dataType}>`;\n        case 4:\n          return `mat2x4<${dataType}>`;\n        default:\n          throw new Error(`${aComponents}-component is not supported.`);\n      }\n    })();\n\n    // Number of quantized values per u32 word and passes needed (each pass extracts 8 values).\n    const valuesPerWord = Math.floor(32 / attributes.bits); // Q4=8, Q2=16\n    const passesPerWord = Math.floor(valuesPerWord / 8); // Q4=1, Q2=2\n\n    const processOneWord = (): string => {\n      let calcStr = '';\n      for (let pass = 0; pass < passesPerWord; pass++) {\n        // Each pass processes 8 values from the current u32 word.\n        // For Q4 (pass=0): shift by 0 and 4. For Q2 (pass 0: shift 0,2; pass 1: shift 4,6).\n        const lowerShift = pass * attributes.bits * 4; // bit offset for lower group within each byte\n        const upperShift = lowerShift + attributes.bits;\n        calcStr += `\n          // reuse a data (pass ${pass})\n            var input_offset${pass > 0 ? pass : ''} = ${pass === 0 ? a.indicesToOffset(`${a.type.indices}(batch, row, word_offset)`) : `input_offset`};\n            var a_data${pass > 0 ? pass : ''}: ${qDqDataType};\n            for (var j${pass > 0 ? pass : ''}: u32 = 0; j${pass > 0 ? pass : ''} < ${8 / aComponents}; j${pass > 0 ? pass : ''}++) {\n              a_data${pass > 0 ? pass : ''}[j${pass > 0 ? pass : ''}] = ${a.getByOffset(`input_offset${pass > 0 ? pass : ''}`)};\n              input_offset${pass > 0 ? pass : ''}++;\n            }\n          `;\n        for (let c = 0; c < components * outputNumber; c++) {\n          calcStr += `\n            b_value = ${bComponents === 1 ? `b${c}_data` : `b${c}_data[i]`};\n            ${\n              attributes.bits === 2\n                ? `{\n              let half_word = b_value >> ${pass * 16}u;\n              let byte_lo = half_word & 0xFFu;\n              let byte_hi = (half_word >> 8u) & 0xFFu;\n              let spread_word = (byte_lo & 0xFu) | ((byte_lo >> 4u) << 8u) | ((byte_hi & 0xFu) << 16u) | ((byte_hi >> 4u) << 24u);\n              b_value_lower = unpack4xU8(spread_word & b_mask);\n              b_value_upper = unpack4xU8((spread_word >> 2u) & b_mask);\n            }`\n                : `b_value_lower = unpack4xU8((b_value >> ${lowerShift}u) & b_mask);\n            b_value_upper = unpack4xU8((b_value >> ${upperShift}u) & b_mask);`\n            }\n            b_quantized_values = ${qDqDataType}(${Array.from(\n              { length: 4 },\n              (_, i) => `${dataType}(b_value_lower[${i}]), ${dataType}(b_value_upper[${i}])`,\n            ).join(', ')});\n            b_dequantized_values = ${(() => {\n              if (aComponents === 1) {\n                return `${qDqDataType}(${Array.from(\n                  { length: 8 },\n                  (_, i) => `(b_quantized_values[${i}] - ${zeroPoints ? `zero_point${c}` : 'zero_point'}) * scale${c}`,\n                ).join(', ')});`;\n              } else {\n                return `(b_quantized_values - ${qDqDataType}(${Array(8)\n                  .fill(`${zeroPoints ? `zero_point${c}` : 'zero_point'}`)\n                  .join(',')})) * scale${c};`;\n              }\n            })()};\n            workgroup_shared[local_id.x * ${outputNumber} + ${Math.floor(c / components)}]${components > 1 ? `[${c % components}]` : ''} += ${Array.from(\n              { length: 8 / aComponents },\n              (_, i) =>\n                `${\n                  aComponents === 1\n                    ? `a_data${pass > 0 ? pass : ''}[${i}] * b_dequantized_values[${i}]`\n                    : `dot(a_data${pass > 0 ? pass : ''}[${i}], b_dequantized_values[${i}])`\n                }`,\n            ).join(' + ')};\n          `;\n        }\n      }\n      return calcStr;\n    };\n    const prepareScaleAndZeroPoint = (): string => {\n      let calcStr = `\n            var col_index = col * ${components};\n            ${\n              zeroPoints\n                ? `\n            let zero_point_values_per_byte: u32 = ${Math.floor(8 / attributes.bits)}u;\n            let zero_point_bytes_per_col = (nBlocksPerCol + zero_point_values_per_byte - 1u) / zero_point_values_per_byte;\n            var zero_point_byte_count: u32;\n            var zero_point_word_index: u32;\n            var zero_point_byte_offset: u32;\n            let zero_point_sub_offset: u32 = block % zero_point_values_per_byte;\n            var zero_point_bits_offset: u32;\n            var zero_point_word: u32;`\n                : `\n            // The default zero point is ${Math.pow(2, attributes.bits - 1)} for unsigned ${attributes.bits}-bit quantization.\n            let zero_point = ${dataType}(${Math.pow(2, attributes.bits - 1).toFixed(1)});`\n            }\n            `;\n      for (let c = 0; c < components * outputNumber; c++) {\n        calcStr += `\n            let scale${c} = ${scales.getByOffset(`col_index * nBlocksPerCol + block`)};\n            ${\n              zeroPoints\n                ? `\n            zero_point_byte_count = col_index * zero_point_bytes_per_col + (block / zero_point_values_per_byte);\n            zero_point_word_index = zero_point_byte_count >> 0x2u;\n            zero_point_byte_offset = zero_point_byte_count & 0x3u;\n            zero_point_bits_offset = (zero_point_byte_offset << 3) + (zero_point_sub_offset * ${attributes.bits}u);\n            zero_point_word = ${zeroPoints.getByOffset('zero_point_word_index')} >> zero_point_bits_offset;\n            let zero_point${c} = ${dataType}((zero_point_word) & ${attributes.bits === 2 ? '0x3u' : '0xFu'});`\n                : ''\n            }\n            col_index += 1;`;\n      }\n      return calcStr;\n    };\n    const prepareBData = (): string => {\n      let calcStr = `col_index = col * ${components};`;\n      for (let c = 0; c < components * outputNumber; c++) {\n        calcStr += `\n            let b${c}_data = ${b.getByIndices(`${b.type.indices}(col_index, block, word)`)};\n            col_index += 1;`;\n      }\n      calcStr += `\n            var b_value: u32;\n            let b_mask: u32 = ${attributes.bits === 2 ? '0x03030303u' : '0x0F0F0F0Fu'};\n            var b_value_lower: vec4<u32>;\n            var b_value_upper: vec4<u32>;\n            var b_quantized_values: ${qDqDataType};\n            var b_dequantized_values: ${qDqDataType};`;\n      return calcStr;\n    };\n    return `\n        var<workgroup> workgroup_shared: array<${output.type.value}, ${outputNumber * workgroupSize}>;\n        ${shaderHelper.declareVariables(...inputVariables, output)}\n        ${shaderHelper.mainStart([workgroupSize, 1, 1])}\n          let output_indices = ${output.offsetToIndices(`(global_idx / ${workgroupSize}) * ${outputNumber}`)};\n          let col = output_indices[2];\n          let row = output_indices[1];\n          let batch = output_indices[0];\n          let nBlocksPerCol = uniforms.b_shape[1];\n\n          for (var block = local_id.x; block < nBlocksPerCol; block += ${workgroupSize}) {\n            //process one block\n            var word_offset: u32 = block * ${attributes.blockSize / aComponents};\n            ${prepareScaleAndZeroPoint()}\n            for (var word: u32 = 0; word < ${blobSizeInWords}; word += ${bComponents}) {\n              ${prepareBData()}\n              for (var i: u32 = 0; i < ${bComponents}; i++) {\n                ${processOneWord()}\n                word_offset += ${valuesPerWord / aComponents};\n              }\n            }\n          }\n          workgroupBarrier();\n\n          if (local_id.x < ${outputNumber}) {\n            var output_value: ${output.type.value} = ${output.type.value}(0);\n            var workgroup_shared_offset: u32 = local_id.x;\n            for (var b: u32 = 0u; b < ${workgroupSize}u; b++) {\n              output_value += workgroup_shared[workgroup_shared_offset];\n              workgroup_shared_offset += ${outputNumber};\n            }\n            ${output.setByIndices(`${output.type.indices}(batch, row, col + local_id.x)`, 'output_value')};\n          }\n        }`;\n  };\n  return {\n    name: 'MatMulNBits',\n    shaderCache: {\n      hint: `${attributes.blockSize};${attributes.bits};${aComponents};${bComponents};${components};${outputNumber};${workgroupSize}`,\n      inputDependencies: Array(inputs.length).fill('rank'),\n    },\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType }],\n      dispatchGroup: { x: dispatchSize },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n\n// Currently, only support blockSize = 32.\nexport const createMatMulNBitsBlockSize32ProgramInfo = (\n  inputs: readonly TensorView[],\n  attributes: MatMulNBitsAttributes,\n): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const aRank = inputShape.length;\n  const dimAOuter = inputShape[aRank - 2];\n  const dimInner = attributes.k;\n  const dimBOuter = attributes.n;\n  const batchDims = inputShape.slice(0, aRank - 2);\n  const batchSize = ShapeUtil.size(batchDims);\n  const blobSize = inputs[1].dims[2];\n  const blobSizeInWords = blobSize / 4;\n  const dataType = inputs[0].dataType;\n  const aComponents = getMaxComponents(attributes.k);\n  const bComponents = getMaxComponents(blobSizeInWords);\n  const outputShape = batchDims.concat([dimAOuter, dimBOuter]);\n\n  const workgroupSize = 128;\n  const workgroupY = dimBOuter % 8 === 0 ? 8 : dimBOuter % 4 === 0 ? 4 : 1;\n  const workgroupX = workgroupSize / workgroupY;\n  const valuesPerWordBs32 = Math.floor(32 / attributes.bits); // Q4=8, Q2=16\n  const tileSize = workgroupX * bComponents * valuesPerWordBs32; // each uint32 has valuesPerWord data.\n  const aLengthPerTile = tileSize / aComponents;\n  const blocksPerTile = tileSize / attributes.blockSize;\n  const dispatchSize = ShapeUtil.size(outputShape) / workgroupY;\n\n  const programUniforms: ProgramUniform[] = [];\n  const inputShapeTemp = [batchSize, dimAOuter, dimInner / aComponents];\n  const bShape = ShapeUtil.convertShape(inputs[1].dims).slice();\n  bShape.splice(-1, 1, blobSizeInWords / bComponents);\n  programUniforms.push(...createTensorShapeVariables(inputShapeTemp));\n  programUniforms.push(...createTensorShapeVariables(bShape));\n  programUniforms.push(...createTensorShapeVariables(inputs[2].dims));\n  if (inputs.length === 4) {\n    programUniforms.push(...createTensorShapeVariables(ShapeUtil.convertShape(inputs[3].dims)));\n  }\n  const outputShapeTemp = [batchSize, dimAOuter, dimBOuter];\n  programUniforms.push(...createTensorShapeVariables(outputShapeTemp));\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const inputRank = inputShapeTemp.length;\n    const a = inputVariable('a', inputs[0].dataType, inputRank, aComponents);\n    const b = inputVariable('b', DataType.uint32, bShape.length, bComponents);\n    const scales = inputVariable('scales', inputs[2].dataType, inputs[2].dims.length);\n    const inputVariables = [a, b, scales];\n    const zeroPoints =\n      inputs.length === 4 ? inputVariable('zero_points', DataType.uint32, inputs[3].dims.length) : undefined;\n    if (zeroPoints) {\n      inputVariables.push(zeroPoints);\n    }\n    const outputRank = outputShapeTemp.length;\n    const output = outputVariable('output', inputs[0].dataType, outputRank);\n    const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n    const readA = () => {\n      switch (aComponents) {\n        case 1:\n          return `\n          let a_data0 = vec4<${dataType}>(sub_a[word_offset], sub_a[word_offset + 1], sub_a[word_offset + 2], sub_a[word_offset + 3]);\n          let a_data1 = vec4<${dataType}>(sub_a[word_offset + 4], sub_a[word_offset + 5], sub_a[word_offset + 6], sub_a[word_offset + 7]);`;\n        case 2:\n          return `\n          let a_data0 = vec4<${dataType}>(sub_a[word_offset], sub_a[word_offset + 1]);\n          let a_data1 = vec4<${dataType}>(sub_a[word_offset + 2], sub_a[word_offset + 3]);`;\n        case 4:\n          return `\n          let a_data0 = sub_a[word_offset];\n          let a_data1 = sub_a[word_offset + 1];`;\n        default:\n          throw new Error(`${aComponents}-component is not supported.`);\n      }\n    };\n\n    return `\n        var<workgroup> sub_a: array<${a.type.value}, ${aLengthPerTile}>;\n        var<workgroup> inter_results: array<array<${output.type.value}, ${workgroupX}>, ${workgroupY}>;\n        ${shaderHelper.declareVariables(...inputVariables, output)}\n        ${shaderHelper.mainStart([workgroupX, workgroupY, 1])}\n          let output_indices = ${output.offsetToIndices(`workgroup_index * ${workgroupY}`)};\n          let col = output_indices[2];\n          let row = output_indices[1];\n          let batch = output_indices[0];\n          let n_blocks_per_col = uniforms.b_shape[1];\n          let num_tiles =  (n_blocks_per_col - 1) / ${blocksPerTile} + 1;\n\n          // Loop over shared dimension.\n          for (var tile: u32 = 0; tile < num_tiles; tile += 1) {\n            let a_col_start = tile * ${aLengthPerTile};\n            // load one tile A data into shared memory.\n            for (var a_offset = local_idx; a_offset < ${aLengthPerTile}; a_offset += ${workgroupSize})\n            {\n              let a_col = a_col_start + a_offset;\n              if (a_col < uniforms.a_shape[2])\n              {\n                sub_a[a_offset] = ${a.getByIndices(`${a.type.indices}(batch, row, a_col)`)};\n              } else {\n                sub_a[a_offset] = ${a.type.value}(0);\n              }\n            }\n            workgroupBarrier();\n\n            // each thread process one block\n            let b_row = col + local_id.y;\n            let block = tile * ${blocksPerTile} + local_id.x;\n            ${\n              zeroPoints\n                ? `\n            let zero_point_values_per_byte: u32 = ${Math.floor(8 / attributes.bits)}u;\n            let zero_point_bytes_per_col = (n_blocks_per_col + zero_point_values_per_byte - 1u) / zero_point_values_per_byte;\n            let zero_point_byte_count = b_row * zero_point_bytes_per_col + (block / zero_point_values_per_byte);\n            let zero_point_word_index = zero_point_byte_count >> 0x2u;\n            let zero_point_byte_offset = zero_point_byte_count & 0x3u;\n            let zero_point_sub_offset: u32 = block % zero_point_values_per_byte;\n            let zero_point_bits_offset = (zero_point_byte_offset << 3) + (zero_point_sub_offset * ${attributes.bits}u);\n            let zero_point_word = ${zeroPoints.getByOffset('zero_point_word_index')} >> zero_point_bits_offset;\n            let zero_point = ${dataType}((zero_point_word) & ${attributes.bits === 2 ? '0x3u' : '0xFu'});`\n                : `\n            // The default zero point is ${Math.pow(2, attributes.bits - 1)} for unsigned ${attributes.bits}-bit quantization.\n            let zero_point = ${dataType}(${Math.pow(2, attributes.bits - 1).toFixed(1)});`\n            }\n            let scale = ${scales.getByOffset(`b_row * n_blocks_per_col + block`)};\n            let b_data = ${b.getByIndices(`${b.type.indices}(b_row, block, 0)`)};\n            var word_offset = local_id.x * ${attributes.blockSize / aComponents};\n            for (var i: u32 = 0; i < ${bComponents}; i++) {\n              let b_value = ${bComponents === 1 ? `b_data` : `b_data[i]`};\n              ${(() => {\n                const passesPerWordBs32 = Math.floor(valuesPerWordBs32 / 8);\n                let code = '';\n                for (let pass = 0; pass < passesPerWordBs32; pass++) {\n                  const lowerShift = pass * attributes.bits * 4;\n                  const upperShift = lowerShift + attributes.bits;\n                  code += `\n              ${readA()}\n              {${\n                attributes.bits === 2\n                  ? `\n                let half_word = b_value >> ${pass * 16}u;\n                let byte_lo = half_word & 0xFFu;\n                let byte_hi = (half_word >> 8u) & 0xFFu;\n                let spread_word = (byte_lo & 0xFu) | ((byte_lo >> 4u) << 8u) | ((byte_hi & 0xFu) << 16u) | ((byte_hi >> 4u) << 24u);\n                let b_value_lower = unpack4xU8(spread_word & 0x03030303u);\n                let b_value_upper = unpack4xU8((spread_word >> 2u) & 0x03030303u);`\n                  : `\n                let b_value_lower = unpack4xU8((b_value >> ${lowerShift}u) & 0x0F0F0F0Fu);\n                let b_value_upper = unpack4xU8((b_value >> ${upperShift}u) & 0x0F0F0F0Fu);`\n              }\n                let b_quantized_values = mat2x4<${dataType}>(${Array.from(\n                  { length: 4 },\n                  (_, i) => `${dataType}(b_value_lower[${i}]), ${dataType}(b_value_upper[${i}])`,\n                ).join(', ')});\n                let b_dequantized_values = (b_quantized_values - mat2x4<${dataType}>(${Array(8).fill('zero_point').join(',')})) * scale;\n                inter_results[local_id.y][local_id.x] += ${Array.from(\n                  { length: 2 },\n                  (_, i) => `${`dot(a_data${i}, b_dequantized_values[${i}])`}`,\n                ).join(' + ')};\n              }\n              word_offset += ${8 / aComponents};`;\n                }\n                return code;\n              })()}\n            }\n            workgroupBarrier();\n          }\n\n          if (local_idx < ${workgroupY}) {\n            var output_value: ${output.type.value} = ${output.type.value}(0);\n            for (var b = 0u; b < ${workgroupX}; b++) {\n              output_value += inter_results[local_idx][b];\n            }\n            if (col + local_idx < uniforms.output_shape[2])\n            {\n              ${output.setByIndices(`${output.type.indices}(batch, row, col + local_idx)`, 'output_value')}\n            }\n          }\n        }`;\n  };\n  return {\n    name: 'BlockwiseMatMulNBits32',\n    shaderCache: {\n      hint: `${attributes.blockSize};${aComponents};${bComponents};${workgroupX};${workgroupY}`,\n      inputDependencies: Array(inputs.length).fill('rank'),\n    },\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType }],\n      dispatchGroup: { x: dispatchSize },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n\nexport const matMulNBits = (context: ComputeContext, attributes: MatMulNBitsAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  if (\n    attributes.blockSize === 32 &&\n    context.adapterInfo.isVendor('intel') &&\n    context.adapterInfo.isArchitecture('gen-12lp')\n  ) {\n    context.compute(createMatMulNBitsBlockSize32ProgramInfo(context.inputs, attributes));\n  } else {\n    context.compute(createMatMulNBitsProgramInfo(context.inputs, attributes));\n  }\n};\n\nexport const parseMatMulNBitsAttributes = (attributes: Record<string, unknown>): MatMulNBitsAttributes =>\n  createAttributeWithCacheKey(attributes as Omit<MatMulNBitsAttributes, keyof AttributeWithCacheKey>);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform } from '../types';\n\nimport {\n  createTensorShapeVariables,\n  getElementAt,\n  IndicesHelper,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  UniformDataElementType,\n  UniformsArrayType,\n} from './common';\n\ninterface PadAttributes {\n  // 0-constant, 1-reflect, 2-edge, 3-wrap\n  readonly mode: number;\n  readonly value: number;\n  readonly pads: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('Too few inputs');\n  }\n  if (inputs[0].dataType !== DataType.float && inputs[0].dataType !== DataType.float16) {\n    throw new Error('Input type must be float or float16.');\n  }\n\n  if (inputs.length >= 2) {\n    let validPads = inputs[0].dims.length * 2 === inputs[1].dims[0];\n    if (inputs.length === 4) {\n      validPads = inputs[3].dims[0] * 2 === inputs[1].dims[0];\n    }\n    if (!validPads) {\n      throw new Error('The pads should be a 1D tensor of shape [2 * input_rank] or [2 * num_axes].');\n    }\n  }\n};\n\nconst getPadConstant = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n            k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n            if (k < 0) {\n              break;\n            }\n            if (k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n              break;\n            }\n            offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n        `;\n  }\n\n  return `\n          value = ${output.type.value}(uniforms.constant_value);\n          for (var i = 0; i < 1; i++) {\n            var offset = 0;\n            var k = 0;\n            ${block}\n            value = x[offset];\n          }\n      `;\n};\n\nconst getPadReflect = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n                k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n                if (k < 0) {\n                  k = -k;\n                }\n                {\n                  let _2n_1 = 2 * (i32(${getElementAt('uniforms.x_shape', i, inputRank)}) - 1);\n                  k = k % _2n_1;\n                  if(k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n                    k = _2n_1 - k;\n                  }\n                }\n                offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n            `;\n  }\n\n  return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n};\n\nconst getPadEdge = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n                k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n                if (k < 0) {\n                  k = 0;\n                }\n                if (k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n                  k = i32(${getElementAt('uniforms.x_shape', i, inputRank)}) - 1;\n                }\n                offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n            `;\n  }\n\n  return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n};\n\nconst getPadWrap = (output: IndicesHelper, inputRank: number, padsLength: number): string => {\n  let block = '';\n  for (let i = inputRank - 1; i >= 0; --i) {\n    block += `\n                k = i32(${output.indicesGet('indices', i)}) - ${getElementAt('uniforms.pads', i, padsLength)};\n                if (k < 0)  {\n                  k += i32(${getElementAt('uniforms.x_shape', i, inputRank)}]);\n                }\n                if (k >= i32(${getElementAt('uniforms.x_shape', i, inputRank)})) {\n                  k -= i32(${getElementAt('uniforms.x_shape', i, inputRank)});\n                }\n                offset += k * i32(${getElementAt('uniforms.x_strides', i, inputRank)});\n            `;\n  }\n\n  return `\n              var offset = 0;\n              var k = 0;\n              ${block}\n              value = x[offset];\n          `;\n};\n\nconst getPadSnippet = (output: IndicesHelper, inputRank: number, attributes: PadAttributes): string => {\n  switch (attributes.mode) {\n    case 0:\n      return getPadConstant(output, inputRank, attributes.pads.length);\n    case 1:\n      return getPadReflect(output, inputRank, attributes.pads.length);\n    case 2:\n      return getPadEdge(output, inputRank, attributes.pads.length);\n    case 3:\n      return getPadWrap(output, inputRank, attributes.pads.length);\n    default:\n      throw new Error('Invalid mode');\n  }\n};\n\nconst createPadProgramInfo = (inputs: readonly TensorView[], attributes: PadAttributes): ProgramInfo => {\n  const outputShape = ShapeUtil.padShape(inputs[0].dims.slice(), attributes.pads);\n  const inputDims = inputs[0].dims;\n  const outputSize = ShapeUtil.size(outputShape);\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.int32, data: attributes.pads },\n  ];\n\n  const isValueFromInput = inputs.length >= 3 && inputs[2].data;\n  if (attributes.mode === 0) {\n    programUniforms.push({ type: isValueFromInput ? inputs[2].dataType : DataType.float, data: attributes.value });\n  }\n\n  programUniforms.push(...createTensorShapeVariables(inputs[0].dims, outputShape));\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank'];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n    const input = inputVariable('x', inputs[0].dataType, inputDims.length);\n    const dataType = input.type.value;\n    const padSnippet = getPadSnippet(output, inputDims.length, attributes);\n    const uniforms: UniformsArrayType = [\n      { name: 'output_size', type: 'u32' },\n      { name: 'pads', type: 'i32', length: attributes.pads.length },\n    ];\n    if (attributes.mode === 0) {\n      uniforms.push({ name: 'constant_value', type: (isValueFromInput ? dataType : 'f32') as UniformDataElementType });\n    }\n\n    return `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}\n            ${shaderHelper.mainStart()}\n            ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n\n            let indices = ${output.offsetToIndices('global_idx')};\n\n            var value = ${dataType}(0);\n            ${padSnippet}\n            output[global_idx] = value;\n        }`;\n  };\n\n  return {\n    name: 'Pad',\n    shaderCache: { hint: `${attributes.mode}${isValueFromInput}`, inputDependencies },\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n      dispatchGroup: { x: Math.ceil(ShapeUtil.size(outputShape) / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n\nconst createPadAttributesFromInputs = (inputs: readonly TensorView[], attributes: PadAttributes): PadAttributes => {\n  if (inputs.length > 1) {\n    const bigInt64Pads = inputs[1].getBigInt64Array();\n    const value =\n      inputs.length >= 3 && inputs[2].data\n        ? inputs[2].dataType === DataType.float16\n          ? inputs[2].getUint16Array()[0]\n          : inputs[2].getFloat32Array()[0]\n        : 0.0;\n\n    const inputRank = inputs[0].dims.length;\n    const updatePads = new Int32Array(2 * inputRank).fill(0);\n    if (inputs.length >= 4) {\n      const axes = inputs[3].getBigInt64Array();\n      for (let i = 0; i < axes.length; i++) {\n        updatePads[Number(axes[i])] = Number(bigInt64Pads[i]);\n        updatePads[Number(axes[i]) + inputRank] = Number(bigInt64Pads[i + axes.length]);\n      }\n    } else {\n      bigInt64Pads.forEach((v, i) => (updatePads[Number(i)] = Number(v)));\n    }\n\n    const pads: number[] = [];\n    updatePads.forEach((v) => pads.push(v));\n\n    return { mode: attributes.mode, value, pads };\n  } else {\n    return attributes;\n  }\n};\n\nexport const pad = (context: ComputeContext, attributes: PadAttributes): void => {\n  validateInputs(context.inputs);\n  const updatedAttributes = createPadAttributesFromInputs(context.inputs, attributes);\n  context.compute(createPadProgramInfo(context.inputs, updatedAttributes), { inputs: [0] });\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { env } from 'onnxruntime-common';\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { PoolConvUtil, ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramInputTensorInfoDependency, ProgramUniform } from '../types';\n\nimport {\n  createTensorShapeVariables,\n  getElementAt,\n  IndicesHelper,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  UniformsArrayType,\n} from './common';\n\n// TODO: support:\n// - ceil_mode                 \"test_maxpool_2d_ceil\"\n// - storage_order             \"test_maxpool_with_argmax_2d_precomputed_strides\"\n// - [MaxPool] dilations       \"test_maxpool_2d_dilations\"\n// - [MaxPool] output[1]       \"test_maxpool_with_argmax_2d_precomputed_pads\"\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (env.webgpu.validateInputContent && (!inputs || inputs.length !== 1)) {\n    throw new Error('Pool ops requires 1 input.');\n  }\n};\n\nconst getAdjustedPoolAttributesAndOutputShape = <AttributeType extends AveragePoolAttributes | MaxPoolAttributes>(\n  input: TensorView,\n  attributes: AttributeType,\n  isGlobalOperator: boolean,\n): [AttributeType, number[]] => {\n  const isChannelsLast = attributes.format === 'NHWC';\n  const inputShapeAsChannelFirst = input.dims.slice();\n  if (isChannelsLast) {\n    inputShapeAsChannelFirst.splice(1, 0, inputShapeAsChannelFirst.pop()!); // Move channel to the second position.\n  }\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, inputShapeAsChannelFirst, kernelShape, strides, dilations, pads);\n\n  const outputShapeAsChannelFirst = PoolConvUtil.computePoolOutputShape(\n    isGlobalOperator,\n    inputShapeAsChannelFirst,\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  const outputShapeAsChannelLast = outputShapeAsChannelFirst.slice();\n  outputShapeAsChannelLast.push(outputShapeAsChannelLast.splice(1, 1)[0]);\n  return [newAttributes, isChannelsLast ? outputShapeAsChannelLast : outputShapeAsChannelFirst];\n};\n\nconst getUniformAndPadInfo = <AttributeType extends AveragePoolAttributes | MaxPoolAttributes>(\n  outputShape: readonly number[],\n  attributes: AttributeType,\n): [ProgramUniform[], UniformsArrayType, boolean, boolean, boolean] => {\n  const isChannelsLast = attributes.format === 'NHWC';\n  const outputSize = ShapeUtil.size(outputShape);\n  const kernelSize = ShapeUtil.size(attributes.kernelShape);\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.uint32, data: kernelSize },\n  ];\n  const uniforms: UniformsArrayType = [\n    { name: 'outputSize', type: 'u32' },\n    { name: 'kernelSize', type: 'u32' },\n  ];\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 pwStartEndNotZero = !!(pwStart + pwEnd);\n    programUniforms.push(\n      { type: DataType.uint32, data: kw },\n      { type: DataType.uint32, data: sw },\n      { type: DataType.uint32, data: pwStart },\n      { type: DataType.uint32, data: pwEnd },\n    );\n    uniforms.push(\n      { name: 'kw', type: 'u32' },\n      { name: 'sw', type: 'u32' },\n      { name: 'pwStart', type: 'u32' },\n      { name: 'pwEnd', type: 'u32' },\n    );\n\n    let phStartEndNotZero = false;\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      phStartEndNotZero = !!(phStart + phEnd);\n      programUniforms.push(\n        { type: DataType.uint32, data: kh },\n        { type: DataType.uint32, data: sh },\n        { type: DataType.uint32, data: phStart },\n        { type: DataType.uint32, data: phEnd },\n      );\n\n      uniforms.push(\n        { name: 'kh', type: 'u32' },\n        { name: 'sh', type: 'u32' },\n        { name: 'phStart', type: 'u32' },\n        { name: 'phEnd', type: 'u32' },\n      );\n    }\n    return [programUniforms, uniforms, true, pwStartEndNotZero, phStartEndNotZero];\n  } else {\n    if (isChannelsLast) {\n      throw new Error('Pooling with kernelShape.length > 2 is not supported for NHWC format.');\n    }\n    const kernelStrides = ShapeUtil.computeStrides(attributes.kernelShape);\n    programUniforms.push(\n      { type: DataType.uint32, data: kernelStrides },\n      { type: DataType.uint32, data: attributes.pads },\n      { type: DataType.uint32, data: attributes.strides },\n    );\n    uniforms.push(\n      { name: 'kernelStrides', type: 'u32', length: kernelStrides.length },\n      { name: 'pads', type: 'u32', length: attributes.pads.length },\n      { name: 'strides', type: 'u32', length: attributes.strides.length },\n    );\n\n    const hasPads = attributes.pads.reduce((sum, cur) => sum + cur);\n    return [programUniforms, uniforms, !!hasPads, false, false];\n  }\n};\n\nconst generatePoolingCode = <AttributeType extends AveragePoolAttributes | MaxPoolAttributes>(\n  shaderHelper: ShaderHelper,\n  x: IndicesHelper,\n  rank: number,\n  outputShapeRank: number,\n  attributes: AttributeType,\n  op1: string,\n  op2: string,\n  start: number,\n  uniforms: UniformsArrayType,\n  hasPads: boolean,\n  pwStartEndNotZero: boolean,\n  phStartEndNotZero: boolean,\n): string => {\n  const isChannelsLast = attributes.format === 'NHWC';\n  const dataType = x.type.value;\n  const output = outputVariable('output', x.type.tensor, outputShapeRank);\n\n  if (attributes.kernelShape.length <= 2) {\n    let codeW = '';\n    let codeH = '';\n    let codeHEnd = '';\n    const dimIdxW = rank - (isChannelsLast ? 2 : 1);\n    if (pwStartEndNotZero) {\n      codeW = `\n                for (var i: u32 = 0u; i < uniforms.kw; i++) {\n                  xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i;\n                  if (xIndices[${dimIdxW}] < 0 || xIndices[${dimIdxW}]\n                      >= uniforms.x_shape[${dimIdxW}]) {\n                    pad++;\n                    continue;\n                  }\n                  let x_val = x[${x.indicesToOffset('xIndices')}];\n                  ${op1}\n                }`;\n    } else {\n      codeW = `\n                for (var i: u32 = 0u; i < uniforms.kw; i++) {\n                  xIndices[${dimIdxW}] = indices[${dimIdxW}] * uniforms.sw - uniforms.pwStart + i;\n                  let x_val = x[${x.indicesToOffset('xIndices')}];\n                  ${op1}\n                }`;\n    }\n\n    if (attributes.kernelShape.length === 2) {\n      const dimIdxH = rank - (isChannelsLast ? 3 : 2);\n      if (phStartEndNotZero) {\n        codeH = `\n                for (var j: u32 = 0u; j < uniforms.kh; j++) {\n                  xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j;\n                  if (xIndices[${dimIdxH}] < 0 || xIndices[${dimIdxH}] >= uniforms.x_shape[${dimIdxH}]) {\n                    pad += i32(uniforms.kw);\n                    continue;\n                  }\n              `;\n      } else {\n        codeH = `\n                for (var j: u32 = 0u; j < uniforms.kh; j++) {\n                  xIndices[${dimIdxH}] = indices[${dimIdxH}] * uniforms.sh - uniforms.phStart + j;\n                `;\n      }\n      codeHEnd = `\n              }\n            `;\n    }\n\n    const poolingCode = `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)}\n\n            ${shaderHelper.mainStart()}\n              ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n\n              let indices = ${output.offsetToIndices('global_idx')};\n              var xIndices = ${output.offsetToIndices('global_idx')};\n\n              var value = ${dataType}(${start});\n              var pad = 0;\n              ${codeH}\n              ${codeW}\n              ${codeHEnd}\n              ${op2}\n\n              output[global_idx] = value;\n            }`;\n    return poolingCode;\n  } else {\n    if (isChannelsLast) {\n      throw new Error('Pooling with kernelShape.length > 2 is not supported for NHWC format.');\n    }\n    const stridesRank = attributes.kernelShape.length;\n    const padsRank = attributes.pads.length;\n    let padCode = '';\n    if (hasPads) {\n      padCode = `\n                if (xIndices[j] >= uniforms.x_shape[j]) {\n                  pad++;\n                  isPad = true;\n                  break;\n                }\n              }\n              if (!isPad) {\n                let x_val = x[${x.indicesToOffset('xIndices')}];\n                ${op1}\n              }`;\n    } else {\n      padCode = `\n              }\n              let x_val = x[${x.indicesToOffset('xIndices')}];\n              ${op1}\n            `;\n    }\n    const poolingCode = `\n            ${shaderHelper.registerUniforms(uniforms).declareVariables(x, output)}\n\n            ${shaderHelper.mainStart()}\n              ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n              let indices = ${output.offsetToIndices('global_idx')};\n              var xIndices = ${output.offsetToIndices('global_idx')};\n\n              var offsets: array<u32, ${stridesRank}>;\n\n              var value = ${dataType}(${start});\n              var pad = 0;\n              var isPad = false;\n\n              for (var i: u32 = 0u; i < uniforms.kernelSize; i++) {\n                var offset = i;\n                for (var j = 0u; j < ${stridesRank - 1}u; j++) {\n                  offsets[j] = offset / ${getElementAt('uniforms.kernelStrides', 'j', stridesRank)};\n                  offset -= offsets[j] * ${getElementAt('uniforms.kernelStrides', 'j', stridesRank)};\n                }\n                offsets[${stridesRank - 1}] = offset;\n\n                isPad = false;\n                for (var j = ${rank - stridesRank}u; j < ${rank}u; j++) {\n                  xIndices[j] = indices[j] * ${getElementAt(\n                    'uniforms.strides',\n                    `j - ${rank - stridesRank}u`,\n                    stridesRank,\n                  )}\n                    + offsets[j - ${rank - stridesRank}u] - ${getElementAt('uniforms.pads', 'j - 2u', padsRank)};\n                  ${padCode}\n              }\n              ${op2}\n\n              output[global_idx] = value;\n            }`;\n    return poolingCode;\n  }\n};\n\nexport interface FormatAttributes {\n  readonly format: 'NHWC' | 'NCHW';\n}\n\nexport interface PoolCommonAttributes extends FormatAttributes {\n  readonly autoPad: string;\n  readonly ceilMode: number;\n  readonly kernelShape: readonly number[];\n  readonly strides: readonly number[];\n  readonly pads: readonly number[];\n}\n\nconst createShaderKeyFromAttributes = (attributes: PoolCommonAttributes): string =>\n  `${attributes.format};${attributes.ceilMode};${attributes.autoPad};${attributes.kernelShape.length}`;\n\nconst createAveragePoolShaderKeyFromAttributes = (attributes: AveragePoolAttributes): string =>\n  `${createShaderKeyFromAttributes(attributes)};${attributes.countIncludePad}`;\n\nconst createMaxPoolShaderKeyFromAttributes = (attributes: MaxPoolAttributes): string =>\n  `${createShaderKeyFromAttributes(attributes)};${attributes.storageOrder};${attributes.dilations}`;\n\nconst parsePoolCommonAttributes = (attributes: Record<string, unknown>): PoolCommonAttributes => ({\n  format: attributes.format as FormatAttributes['format'],\n  autoPad: ['NOTSET', 'VALID', 'SAME_UPPER', 'SAME_LOWER'][attributes.auto_pad as number],\n  ceilMode: attributes.ceil_mode as number,\n  kernelShape: attributes.kernel_shape as [number, number],\n  strides: attributes.strides as [number, number],\n  pads: attributes.pads as [number, number, number, number],\n});\n\nexport interface AveragePoolAttributes extends PoolCommonAttributes, AttributeWithCacheKey {\n  readonly countIncludePad: boolean;\n}\n\nconst createAveragePoolProgramInfo = (\n  name: string,\n  input: TensorView,\n  isGlobalOperator: boolean,\n  attributes: AveragePoolAttributes,\n): ProgramInfo => {\n  const [adjustedAttributes, outputShape] = getAdjustedPoolAttributesAndOutputShape(\n    input,\n    attributes,\n    isGlobalOperator,\n  );\n  const x = inputVariable('x', input.dataType, input.dims.length);\n  const dataType = x.type.value;\n\n  const op1 = 'value += x_val;';\n  let op2 = '';\n  if (adjustedAttributes.countIncludePad) {\n    op2 += `value /= ${dataType}(uniforms.kernelSize);`;\n  } else {\n    op2 += `value /= ${dataType}(i32(uniforms.kernelSize) - pad);`;\n  }\n  const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] = getUniformAndPadInfo(\n    outputShape,\n    adjustedAttributes,\n  );\n  programUniforms.push(...createTensorShapeVariables(input.dims, outputShape));\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank'];\n  return {\n    name,\n    shaderCache: {\n      hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`,\n      inputDependencies,\n    },\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: input.dataType }],\n      dispatchGroup: { x: Math.ceil(ShapeUtil.size(outputShape) / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n    getShaderSource: (shaderHelper) =>\n      generatePoolingCode(\n        shaderHelper,\n        x,\n        input.dims.length,\n        outputShape.length,\n        adjustedAttributes,\n        op1,\n        op2,\n        0.0,\n        uniforms,\n        hasPads,\n        pwStartEndNotZero,\n        phStartEndNotZero,\n      ),\n  };\n};\n\nexport const parseAveragePoolAttributes = (attributes: Record<string, unknown>): AveragePoolAttributes => {\n  const countIncludePad = (attributes.count_include_pad as number) === 0 ? false : true;\n\n  const attr = parsePoolCommonAttributes(attributes);\n  // TODO: support attribute 'ceil_mode'\n  if (attr.ceilMode !== 0) {\n    throw new Error('using ceil() in shape computation is not yet supported for AveragePool');\n  }\n  const averagePoolAttributes = { countIncludePad, ...attr, cacheKey: '' };\n  return { ...averagePoolAttributes, cacheKey: createAveragePoolShaderKeyFromAttributes(averagePoolAttributes) };\n};\n\nexport const averagePool = (context: ComputeContext, attributes: AveragePoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createAveragePoolProgramInfo('AveragePool', context.inputs[0], false, attributes));\n};\n\nconst globalPoolAttributes = {\n  autoPad: '',\n  ceilMode: 0,\n  countIncludePad: false,\n  kernelShape: [],\n  strides: [],\n  pads: [],\n  storageOrder: 0,\n  dilations: [],\n};\n\nexport const parseGlobalAveragePoolAttributes = (attributes: Record<string, unknown>): AveragePoolAttributes => {\n  const format = attributes.format as FormatAttributes['format'];\n  return { format, ...globalPoolAttributes, cacheKey: format };\n};\n\nexport const globalAveragePool = (context: ComputeContext, attributes: AveragePoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createAveragePoolProgramInfo('GlobalAveragePool', context.inputs[0], true, attributes));\n};\n\nexport interface MaxPoolAttributes extends PoolCommonAttributes, AttributeWithCacheKey {\n  readonly storageOrder: number;\n  readonly dilations: number[];\n}\n\nconst createMaxPoolProgramInfo = (\n  name: string,\n  input: TensorView,\n  isGlobalOperator: boolean,\n  attributes: MaxPoolAttributes,\n): ProgramInfo => {\n  const [adjustedAttributes, outputShape] = getAdjustedPoolAttributesAndOutputShape(\n    input,\n    attributes,\n    isGlobalOperator,\n  );\n  const op1 = `\n      value = max(x_val, value);\n    `;\n  const op2 = '';\n  const x = inputVariable('x', input.dataType, input.dims.length);\n  const inputDependencies: ProgramInputTensorInfoDependency[] = ['rank'];\n  const [programUniforms, uniforms, hasPads, pwStartEndNotZero, phStartEndNotZero] = getUniformAndPadInfo(\n    outputShape,\n    adjustedAttributes,\n  );\n  programUniforms.push(...createTensorShapeVariables(input.dims, outputShape));\n  return {\n    name,\n    shaderCache: {\n      hint: `${attributes.cacheKey};${hasPads};${pwStartEndNotZero};${phStartEndNotZero}`,\n      inputDependencies,\n    },\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: input.dataType }],\n      dispatchGroup: { x: Math.ceil(ShapeUtil.size(outputShape) / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n    getShaderSource: (shaderHelper) =>\n      generatePoolingCode(\n        shaderHelper,\n        x,\n        input.dims.length,\n        outputShape.length,\n        adjustedAttributes,\n        op1,\n        op2,\n        input.dataType === DataType.float16 ? -65504 : -1e5,\n        uniforms,\n        hasPads,\n        pwStartEndNotZero,\n        phStartEndNotZero,\n      ),\n  };\n};\n\nexport const maxPool = (context: ComputeContext, attributes: MaxPoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createMaxPoolProgramInfo('MaxPool', context.inputs[0], false, attributes));\n};\n\nexport const parseMaxPoolAttributes = (attributes: Record<string, unknown>): MaxPoolAttributes => {\n  const storageOrder = attributes.storage_order as number;\n  const dilations = attributes.dilations as [number, number];\n\n  const attr = parsePoolCommonAttributes(attributes);\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 (attr.ceilMode !== 0) {\n    throw new Error('using ceil() in shape computation is not yet supported for MaxPool');\n  }\n  const maxPoolAttributes = { storageOrder, dilations, ...attr, cacheKey: '' };\n  return { ...maxPoolAttributes, cacheKey: createMaxPoolShaderKeyFromAttributes(maxPoolAttributes) };\n};\n\nexport const parseGlobalMaxPoolAttributes = (attributes: Record<string, unknown>): MaxPoolAttributes => {\n  const format = attributes.format as FormatAttributes['format'];\n  return { format, ...globalPoolAttributes, cacheKey: format };\n};\n\nexport const globalMaxPool = (context: ComputeContext, attributes: MaxPoolAttributes): void => {\n  validateInputs(context.inputs);\n  context.compute(createMaxPoolProgramInfo('GlobalMaxPool', context.inputs[0], true, attributes));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramUniform } from '../types';\n\nimport {\n  createTensorShapeVariables,\n  getMaxComponents,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  UniformsArrayType,\n} from './common';\n\nexport interface DequantizeLinerAttributes extends AttributeWithCacheKey {\n  axis: number;\n  blockSize: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: DequantizeLinerAttributes): void => {\n  if (inputs.length < 2 || inputs.length > 3) {\n    throw new Error('DequantizeLinear requires 2 or 3 inputs.');\n  }\n  if (inputs.length === 3 && inputs[1].dims === inputs[2].dims) {\n    throw new Error('x-scale and x-zero-point must have the same shape.');\n  }\n  if (inputs.length === 3 && inputs[0].dataType !== inputs[2].dataType) {\n    throw new Error('x and x-zero-point must have the same data type.');\n  }\n  if (inputs[1].dims.length !== 0 && inputs[1].dims.length !== 1 && inputs[1].dims.length !== inputs[0].dims.length) {\n    throw new Error('scale input must be a scalar, a 1D tensor, or have the same rank as the input tensor.');\n  }\n  // validate scale and zero-point input shapes\n  if (inputs.length > 2) {\n    // zero-point input type should be the same as input data type.\n    if (inputs[0].dataType !== inputs[2].dataType) {\n      throw new Error('x and x-zero-point must have the same data type.');\n    }\n    // Scale and zero-point inputs must have the same shape\n    if (inputs[1].dims.length !== inputs[2].dims.length) {\n      throw new Error('scale and zero-point inputs must have the same rank.');\n    }\n    if (!inputs[1].dims.map((d, i) => d === inputs[2].dims[i]).reduce((a, b) => a && b, true)) {\n      throw new Error('scale and zero-point inputs must have the same shape.');\n    }\n  }\n  // Validate blockSize\n  if (attributes.blockSize > 0) {\n    // Block qunatization\n    if (inputs[1].dims.length === 0 || (inputs[1].dims.length === 1 && inputs[1].dims[0] === 1)) {\n      throw new Error('blockSize must be set only for block quantization.');\n    }\n    if (\n      !inputs[1].dims.map((d, i) => i === attributes.axis || d === inputs[0].dims[i]).reduce((a, b) => a && b, true)\n    ) {\n      throw new Error('For block qunatization, scale input shape to match the input shape except for the axis');\n    }\n    // Scale input rank should be same as the input rank\n    if (inputs[1].dims.length !== inputs[0].dims.length) {\n      throw new Error('For block qunatization the scale input rank must be the same as the x rank.');\n    }\n    const dI = inputs[0].dims[attributes.axis];\n    const si = inputs[1].dims[attributes.axis];\n    if (attributes.blockSize < Math.ceil(dI / si) || attributes.blockSize > Math.ceil(dI / (si - 1) - 1)) {\n      throw new Error('blockSize must be with in the range [ceil(dI / Si), ceil(dI / (Si - 1) - 1)].');\n    }\n  }\n};\n\nconst createDequantizeLinearProgramInfo = (\n  inputs: readonly TensorView[],\n  attributes: DequantizeLinerAttributes,\n): ProgramInfo => {\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, inputs[0].dims.length);\n  const inputType = inputs[0].dataType;\n  const isSigned = inputType === DataType.int8;\n  const outputShape = inputs[0].dims; // output shape is same as the input shape\n  const dataType = inputs[1].dataType; // output type is same as the the scale input type\n  const outputSize = ShapeUtil.size(outputShape);\n  const isPacked = inputType === DataType.int8 || inputType === DataType.uint8;\n  const inputShape = isPacked ? [Math.ceil(ShapeUtil.size(inputs[0].dims) / 4)] : inputs[0].dims;\n  const scaleShape = inputs[1].dims;\n  const zeroPointInput = inputs.length > 2 ? inputs[2] : undefined;\n  const zeroPointShape = zeroPointInput\n    ? isPacked\n      ? [Math.ceil(ShapeUtil.size(zeroPointInput.dims) / 4)]\n      : zeroPointInput.dims\n    : undefined;\n  // Scales input is a scaler for per-tensor/per-layer quantization, 1-D tensor for per-axis quantization\n  // or tensor with same rank as input for blocked quantization.\n  const perLayerQuantization = scaleShape.length === 0 || (scaleShape.length === 1 && scaleShape[0] === 1);\n  const perAxisQuantization = perLayerQuantization === false && scaleShape.length === 1;\n  // Left unnecessary commented-out assignment for documentation\n  // const blockQuantization = perLayerQuantization === false && perAxisQuantization === false;\n  const maxComponents = getMaxComponents(outputSize);\n  const useComponents = perLayerQuantization && (!isPacked || maxComponents === 4);\n  const components = useComponents ? maxComponents : 1;\n  const inputComponent = useComponents && !isPacked ? maxComponents : 1;\n  const input = inputVariable('input', isPacked ? DataType.uint32 : inputType, inputShape.length, inputComponent);\n  const scale = inputVariable('scale', dataType, scaleShape.length);\n  const zeroPoint = zeroPointInput\n    ? inputVariable('zero_point', isPacked ? DataType.uint32 : inputType, zeroPointShape!.length)\n    : undefined;\n  const output = outputVariable('output', dataType, outputShape.length, components);\n  const inputVariables = [input, scale];\n  if (zeroPoint) {\n    inputVariables.push(zeroPoint);\n  }\n  const inputShapes = [inputShape, scaleShape];\n  if (zeroPointInput) {\n    inputShapes.push(zeroPointShape!);\n  }\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize / components },\n    { type: DataType.uint32, data: axis },\n    { type: DataType.uint32, data: attributes.blockSize },\n    ...createTensorShapeVariables(...inputShapes, outputShape),\n  ];\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const uniforms: UniformsArrayType = [\n      { name: 'output_size', type: 'u32' },\n      { name: 'axis', type: 'u32' },\n      { name: 'block_size', type: 'u32' },\n    ];\n    return `\n      ${shaderHelper.registerUniforms(uniforms).declareVariables(...inputVariables, output)}\n      ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n          let output_indices = ${output.offsetToIndices('global_idx')};\n\n          // Set input x\n          ${(() => {\n            if (isPacked) {\n              return `\n            let input = ${input.getByOffset('global_idx / 4')};\n            let x_vec = ${isSigned ? 'unpack4xI8(input)' : 'unpack4xU8(input)'};\n            let x_value = ${components === 1 ? 'x_vec[global_idx % 4]' : 'x_vec'};`;\n            } else {\n              return `let x_value = ${input.getByOffset('global_idx')};`;\n            }\n          })()};\n\n          // Set scale input\n          ${(() => {\n            if (perLayerQuantization) {\n              // scale input is a scalar ()\n              return `let scale_value= ${scale.getByOffset('0')}`;\n            } else if (perAxisQuantization) {\n              // scale input is a 1D tensor\n              return `\n            let scale_index = ${output.indicesGet('output_indices', 'uniforms.axis')};\n            let scale_value= ${scale.getByOffset('scale_index')};`;\n            } else {\n              // Block quantization. Scale input rank is same as input/output rank.\n              return `\n            var scale_indices: ${scale.type.indices} = output_indices;\n            let index = ${scale.indicesGet('scale_indices', 'uniforms.axis')} / uniforms.block_size;\n            ${scale.indicesSet('scale_indices', 'uniforms.axis', 'index')};\n            let scale_value= ${scale.getByIndices('scale_indices')};`;\n            }\n          })()};\n\n          // Set zero-point input\n          ${(() => {\n            if (zeroPoint) {\n              if (perLayerQuantization) {\n                // zero-point input is a scalar\n                if (isPacked) {\n                  return `\n                let zero_point_input = ${zeroPoint.getByOffset('0')};\n                let zero_point_vec =  ${isSigned ? 'unpack4xI8(zero_point_input)' : 'unpack4xU8(zero_point_input)'};\n                let zero_point_value= zero_point_vec[0]`;\n                } else {\n                  return `let zero_point_value = ${zeroPoint.getByOffset('0')}`;\n                }\n              } else if (perAxisQuantization) {\n                // zero-point input is a 1D tensor\n                if (isPacked) {\n                  return `\n                let zero_point_index = ${output.indicesGet('output_indices', 'uniforms.axis')};\n                let zero_point_input = ${zeroPoint.getByOffset('zero_point_index / 4')};\n                let zero_point_vec =  ${isSigned ? 'unpack4xI8(zero_point_input)' : 'unpack4xU8(zero_point_input)'};\n                let zero_point_value = zero_point_vec[zero_point_index % 4]`;\n                } else {\n                  return `\n                let zero_point_index = ${output.indicesGet('output_indices', 'uniforms.axis')};\n                let zero_point_value = ${zeroPoint.getByOffset('zero_point_index')};`;\n                }\n              } else {\n                // BlockedQuantization. The zero-point input shape is same as the input shape except along axis.\n                if (isPacked) {\n                  return `\n                let zero_point_offset = ${scale.indicesToOffset('scale_indices')};\n                let zero_point_input = ${zeroPoint.getByOffset('zero_point_offset / 4')};\n                let zero_point_vec = ${isSigned ? 'unpack4xI8(zero_point_input)' : 'unpack4xU8(zero_point_input)'};\n                let zero_point_value = zero_point_vec[zero_point_offset % 4];`;\n                } else {\n                  return `let zero_point_value = ${zeroPoint.getByIndices('scale_indices')};`;\n                }\n              }\n            } else {\n              return `let zero_point_value = ${isPacked ? (isSigned ? 'i32' : 'u32') : input.type.value}(0);`;\n            }\n          })()};\n      // Compute and write output\n      ${output.setByOffset('global_idx', `${output.type.value}(x_value - zero_point_value) * scale_value`)};\n      }`;\n  };\n  return {\n    name: 'DequantizeLinear',\n    shaderCache: {\n      hint: attributes.cacheKey,\n      inputDependencies: zeroPoint ? ['rank', 'rank', 'rank'] : ['rank', 'rank'],\n    },\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / components / 64), y: 1, z: 1 },\n      programUniforms,\n    }),\n  };\n};\n\nexport const dequantizeLinear = (context: ComputeContext, attributes: DequantizeLinerAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  context.compute(createDequantizeLinearProgramInfo(context.inputs, attributes));\n};\n\nexport const parseDequantizeLinearAttributes = (attributes: Record<string, unknown>): DequantizeLinerAttributes =>\n  createAttributeWithCacheKey({ axis: attributes.axis as number, blockSize: attributes.blockSize as number });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { env } from 'onnxruntime-common';\n\nimport { DataType } from '../../../wasm-common';\nimport { ComputeContext, ProgramInfo, ProgramUniform } from '../types';\n\nimport {\n  createTensorShapeVariables,\n  outputVariable,\n  ShaderHelper,\n  UniformDataElementType,\n  UniformsArrayType,\n} from './common';\n\nconst validateInputsContent = (start: number, limit: number, delta: number): void => {\n  const sameStartLimit = start === limit;\n  const increasingRangeNegativeStep = start < limit && delta < 0;\n  const decreasingRangePositiveStep = start > limit && delta > 0;\n\n  if (sameStartLimit || increasingRangeNegativeStep || decreasingRangePositiveStep) {\n    throw new Error(\"Range these inputs' contents are invalid.\");\n  }\n};\n\nconst createRangeProgramInfo = (start: number, limit: number, delta: number, dataType: DataType): ProgramInfo => {\n  const numElements = Math.abs(Math.ceil((limit - start) / delta));\n  const outputShape: number[] = [numElements];\n  const outputSize = numElements;\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: dataType, data: start },\n    { type: dataType, data: delta },\n    ...createTensorShapeVariables(outputShape),\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const output = outputVariable('output', dataType, outputShape.length);\n    const wgslType = output.type.value;\n    const uniforms: UniformsArrayType = [\n      { name: 'outputSize', type: 'u32' },\n      { name: 'start', type: wgslType as UniformDataElementType },\n      { name: 'delta', type: wgslType as UniformDataElementType },\n    ];\n    return `\n        ${shaderHelper.registerUniforms(uniforms).declareVariables(output)}\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n        output[global_idx] = uniforms.start + ${wgslType}(global_idx) * uniforms.delta;\n      }`;\n  };\n\n  return {\n    name: 'Range',\n    shaderCache: { hint: `${dataType}` },\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n  };\n};\n\nexport const range = (context: ComputeContext): void => {\n  let start = 0;\n  let limit = 0;\n  let delta = 0;\n  if (context.inputs[0].dataType === DataType.int32) {\n    start = context.inputs[0].getInt32Array()[0];\n    limit = context.inputs[1].getInt32Array()[0];\n    delta = context.inputs[2].getInt32Array()[0];\n  } else if (context.inputs[0].dataType === DataType.float) {\n    start = context.inputs[0].getFloat32Array()[0];\n    limit = context.inputs[1].getFloat32Array()[0];\n    delta = context.inputs[2].getFloat32Array()[0];\n  }\n  if (env.webgpu.validateInputContent) {\n    validateInputsContent(start, limit, delta);\n  }\n\n  context.compute(createRangeProgramInfo(start, limit, delta, context.inputs[0].dataType), { inputs: [] });\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramUniform } from '../types';\n\nimport {\n  atomicOutputVariable,\n  createTensorShapeVariables,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n} from './common';\n\nexport interface ScatterNDAttributes extends AttributeWithCacheKey {\n  reduction: string;\n}\n\ntype ReductionType = 'i32' | 'u32' | 'f32';\n\nconst atomicReductionSnippet = (reduction: string, ptr: string, v: string, type: ReductionType) => {\n  if (reduction !== 'none' && type !== 'i32' && type !== 'u32' && type !== 'f32') {\n    throw new Error(`Input ${type} is not supported with reduction ${reduction}.`);\n  }\n\n  const floatStart = `{\n                var oldValue = 0;\n                loop {\n                  let newValueF32 =`;\n  const floatEnd = `;\n                  let newValue = bitcast<i32>(newValueF32);\n                  let res = atomicCompareExchangeWeak(&${ptr}, oldValue, newValue);\n                  if res.exchanged {\n                    break;\n                  }\n                  oldValue = res.old_value;\n                }\n              }`;\n\n  switch (reduction) {\n    case 'none':\n      return `${ptr}=${v};`;\n    case 'add':\n      if (type === 'i32' || type === 'u32') {\n        return `atomicAdd(&${ptr}, bitcast<${type}>(${v}));`;\n      } else {\n        // atomicAdd only supports uint/int type. For float, we use\n        // atomicCompareExchangeWeak to simulate.\n        return `\n              ${floatStart}bitcast<${type}>(oldValue) + (${v})${floatEnd}`;\n      }\n    case 'max':\n      if (type === 'i32' || type === 'u32') {\n        return `atomicMax(&${ptr}, bitcast<${type}>(${v}));`;\n      } else {\n        // atomicMax only supports uint/int type. For float, we use\n        // atomicCompareExchangeWeak to simulate.\n        return `\n                ${floatStart}max(bitcast<f32>(oldValue), (${v}))${floatEnd}`;\n      }\n    case 'min':\n      if (type === 'i32' || type === 'u32') {\n        return `atomicMin(&${ptr}, bitcast<${type}>(${v}));`;\n      } else {\n        // atomicMin only supports uint/int type. For float, we use\n        // atomicCompareExchangeWeak to simulate.\n        return `${floatStart}min(bitcast<${type}>(oldValue), (${v}))${floatEnd}`;\n      }\n    case 'mul':\n      // atomicMul is not supported, we use atomicCompareExchangeWeak to simulate.\n      return `${floatStart}(bitcast<${type}>(oldValue) * (${v}))${floatEnd}`;\n\n    default:\n      throw new Error(`Reduction ${reduction} is not supported.`);\n  }\n};\n\nconst createScatterNDProgramInfo = (inputs: readonly TensorView[], attributes: ScatterNDAttributes): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const indicesShape = inputs[1].dims;\n  const outputShape = inputShape;\n  // TODO: support bool with components 4.\n  const components = 1;\n  const outputSize = Math.ceil(ShapeUtil.sizeToDimension(indicesShape, indicesShape.length - 1) / components);\n  const lastIndexDimension = indicesShape[indicesShape.length - 1];\n  const numUpdatesElements = ShapeUtil.sizeFromDimension(inputShape, lastIndexDimension);\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.uint32, data: lastIndexDimension },\n    { type: DataType.uint32, data: numUpdatesElements },\n    ...createTensorShapeVariables(inputs[1].dims, inputs[2].dims, outputShape),\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const indices = inputVariable('indices', inputs[1].dataType, inputs[1].dims.length);\n    const updates = inputVariable('updates', inputs[2].dataType, inputs[2].dims.length, components);\n    const output =\n      attributes.reduction !== 'none' && attributes.reduction !== ''\n        ? atomicOutputVariable('output', inputs[0].dataType, outputShape.length)\n        : outputVariable('output', inputs[0].dataType, outputShape.length, components);\n\n    return `\n      ${shaderHelper\n        .registerUniform('output_size', 'u32')\n        .registerUniform('last_index_dimension', 'u32')\n        .registerUniform('num_updates_elements', 'u32')\n        .declareVariables(indices, updates, output)}\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n  var data_offset = 0u;\n  let indices_start = uniforms.last_index_dimension * global_idx;\n  let indices_end = indices_start + uniforms.last_index_dimension;\n  for (var i = indices_start; i < indices_end; i++) {\n    var index = i32(indices[i].x);\n    ${\n      inputs[0].dims.length === 1\n        ? `\n    let element_count_dim = uniforms.output_strides;\n    let dim_value = uniforms.output_shape;`\n        : `\n    let element_count_dim = uniforms.output_strides[i - indices_start];\n    let dim_value = uniforms.output_shape[i - indices_start];`\n    }\n    if (index >= 0) {\n      if (index >= i32(dim_value)) {\n        index = i32(dim_value - 1);\n      }\n    } else {\n      if (index < -i32(dim_value)) {\n        index = 0;\n      } else {\n        index += i32(dim_value);\n      }\n    }\n    data_offset += u32((u32(index) * element_count_dim));\n  }\n\n  for (var i = 0u; i < uniforms.num_updates_elements; i++) {\n    let value = updates[uniforms.num_updates_elements * global_idx + i];\n    ${atomicReductionSnippet(\n      attributes.reduction,\n      'output[data_offset + i]',\n      'value',\n      output.type.value as ReductionType,\n    )}\n  }\n\n      }`;\n  };\n  return {\n    name: 'ScatterND',\n    shaderCache: {\n      hint: `${attributes.cacheKey}_${attributes.reduction}`,\n      inputDependencies: ['rank', 'rank'],\n    },\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n    getShaderSource,\n  };\n};\n\nexport const parseScatterNDAttributes = (attributes: Record<string, unknown>): ScatterNDAttributes =>\n  createAttributeWithCacheKey({ reduction: attributes.reduction as string });\n\nexport const scatterND = (context: ComputeContext, attributes: ScatterNDAttributes): void => {\n  context.compute(createScatterNDProgramInfo(context.inputs, attributes), {\n    inputs: [context.inputs[1], context.inputs[2]],\n    outputs: [],\n  });\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo } from '../types';\n\nimport {\n  createTensorShapeVariables,\n  getElementAt,\n  IndicesHelper,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n} from './common';\n\ntype CoordinateTransformMode =\n  | 'half_pixel'\n  | 'asymmetric'\n  | 'pytorch_half_pixel'\n  | 'tf_half_pixel_for_nn'\n  | 'align_corners'\n  | 'tf_crop_and_resize'\n  | 'half_pixel_symmetric';\n\ntype KeepAspectRatioPolicy = 'stretch' | 'not_smaller' | 'not_larger';\n\ntype Mode = 'nearest' | 'linear' | 'cubic';\n\ntype NearestMode = 'round_prefer_floor' | 'round_prefer_ceil' | 'floor' | 'ceil' | 'simple';\n\nexport interface ResizeAttributes extends AttributeWithCacheKey {\n  antialias: number;\n  axes: number[];\n  coordinateTransformMode: CoordinateTransformMode;\n  cubicCoeffA: number;\n  excludeOutside: boolean;\n  extrapolationValue: number;\n  keepAspectRatioPolicy: KeepAspectRatioPolicy;\n  mode: Mode;\n  nearestMode: NearestMode;\n}\n\nconst validateScales = (scales: number[], attributes: ResizeAttributes): void => {\n  scales.every(\n    (value) =>\n      value > 0 ||\n      (() => {\n        throw new Error('Resize requires scales input values to be positive');\n      }),\n  );\n  // Check scales dims based on mode: LINEAR, CUBIC\n  if (scales.length > 0) {\n    if (attributes.mode === 'linear') {\n      if (\n        !(\n          scales.length === 2 ||\n          scales.length === 3 ||\n          (scales.length === 4 && scales[0] === 1 && scales[1] === 1) ||\n          (scales.length === 4 && scales[0] === 1 && scales[3] === 1) ||\n          (scales.length === 5 && scales[0] === 1 && scales[1] === 1)\n        )\n      ) {\n        throw new Error(\n          `For linear mode, Resize requires scales to be 2D, 3D, 4D with either two outermost or one innermost and\n            one outermost scale values equal to 1, or 5D with two outermost scale values equal to 1`,\n        );\n      }\n    } else if (attributes.mode === 'cubic') {\n      if (\n        !(\n          scales.length === 2 ||\n          (scales.length === 4 && scales[0] === 1 && scales[1] === 1) ||\n          (scales.length === 4 && scales[0] === 1 && scales[3] === 1)\n        )\n      ) {\n        throw new Error('Resize requires scales input size to be 2 or 4 for cubic mode');\n      }\n    }\n  }\n};\n\nconst updateScales = (scales: readonly number[], axes: readonly number[], rank: number): number[] => {\n  axes.every(\n    (value) =>\n      (value >= 0 && value < rank) ||\n      (() => {\n        throw new Error('Resize requires axes input values to be positive and less than rank');\n      }),\n  );\n  const newScales = new Array(rank).fill(1.0);\n  axes.forEach((value, index) => (newScales[value] = scales[index]));\n  return newScales;\n};\n\nconst validateInputs = (\n  inputs: readonly TensorView[],\n  attributes: ResizeAttributes,\n  opsetVersion: number,\n  scales: number[],\n  sizes: number[],\n  roi: number[],\n): void => {\n  const [roiInputIndex, scalesInputIndex, sizesInputIndex] =\n    opsetVersion > 10 ? [1, 2, 3] : [-1, inputs.length > 1 ? 1 : -1, -1];\n  const rank = inputs[0].dims.length;\n  if (roiInputIndex > 0 && inputs.length > roiInputIndex && inputs[roiInputIndex].dims.length > 0) {\n    inputs[roiInputIndex].getFloat32Array().forEach((value) => roi.push(value));\n  } else if (attributes.coordinateTransformMode === 'tf_crop_and_resize') {\n    throw new Error('Resize requires RoI input to be specified when coordinateTransformMode is tfCropAndResize');\n  }\n\n  if (\n    scalesInputIndex > 0 &&\n    inputs.length > scalesInputIndex &&\n    inputs[scalesInputIndex].dims.length === 1 &&\n    inputs[scalesInputIndex].dims[0] > 0\n  ) {\n    inputs[scalesInputIndex].getFloat32Array().forEach((value) => scales.push(value));\n    if (\n      scales.length !== 0 &&\n      scales.length !== rank &&\n      opsetVersion >= 18 &&\n      scales.length !== attributes.axes.length\n    ) {\n      throw new Error('Resize requires scales input size to be same as input rank or axes size for opset 18 and up');\n    }\n    validateScales(scales, attributes);\n    if (attributes.axes.length > 0) {\n      updateScales(scales, attributes.axes, rank).forEach((value, index) => (scales[index] = value));\n    }\n  }\n  if (\n    sizesInputIndex > 0 &&\n    inputs.length > sizesInputIndex &&\n    inputs[sizesInputIndex].dims.length === 1 &&\n    inputs[sizesInputIndex].dims[0] > 0\n  ) {\n    inputs[sizesInputIndex].getBigInt64Array().forEach((value) => sizes.push(Number(value)));\n    if (sizes.length !== 0 && sizes.length !== rank && opsetVersion >= 18 && sizes.length !== attributes.axes.length) {\n      throw new Error('Resize requires sizes input size to be same as input rank or axes size for opset 18 and up');\n    }\n  }\n\n  if (attributes.axes.length > 0) {\n    if (scales.length !== 0 && scales.length !== attributes.axes.length) {\n      throw new Error('Resize requires \"scales\" input size to be of axes rank when axes attributes is specified');\n    }\n    if (sizes.length !== 0 && sizes.length !== attributes.axes.length) {\n      throw new Error('Resize requires \"sizes\" input size to be of rank axes rank when axes attributes is specified');\n    }\n  }\n  if (typeof scales !== 'undefined' && typeof sizes !== 'undefined' && scales.length > 0 && sizes.length > rank) {\n    throw new Error('Resize requires only of scales or sizes to be specified');\n  }\n};\n\nconst getSafeIntegerDivision = (a: string, b: string, c: string, dType: string): string => `\n  // The whole part and the fractional part are calculated separately due to inaccuracy of floating\n  // point division. As an example, f32(21) / f32(7) may evaluate to 2.99... instead of 3, causing an\n  // offset-by-one error later in floor().\n  let big = (${a}) * (${b});\n  let whole = ${dType}(big / (${c}));\n  let fract = ${dType}(big % (${c})) / ${dType}(${c});\n  return whole + fract;\n`;\n\nconst getOriginalCoordinateFromResizedCoordinate = (\n  coordinateTransferMode: CoordinateTransformMode,\n  dType: string,\n): string =>\n  `fn getOriginalCoordinateFromResizedCoordinate(xResized: u32, xScale: f32, lengthResized: u32,\n     lengthOriginal: u32, roiStart: f32, roiEnd: f32) -> ${dType} { ` +\n  (() => {\n    switch (coordinateTransferMode) {\n      case 'asymmetric':\n        return `\n          if (xScale < 1.0 || floor(xScale) != xScale) {\n            return ${dType}(xResized) / ${dType}(xScale);\n          } else {\n            ${getSafeIntegerDivision('xResized', 'lengthOriginal', 'lengthResized', dType)}\n          }\n        `;\n      case 'pytorch_half_pixel':\n        return `if (lengthResized > 1) {\n                    return (${dType}(xResized) + 0.5) / ${dType}(xScale) - 0.5;\n                  } else {\n                    return 0.0;\n                  }`;\n      case 'tf_half_pixel_for_nn':\n        return `return (${dType}(xResized) + 0.5) / ${dType}(xScale);`;\n      case 'align_corners':\n        return `if (lengthResized == 1) {\n                    return 0.0;\n                  } else {\n                    ${getSafeIntegerDivision('xResized', 'lengthOriginal - 1', 'lengthResized - 1', dType)}\n                  }`;\n      case 'tf_crop_and_resize':\n        return `if (lengthResized > 1) {\n                    return ${dType}(roiStart) * ${dType}(lengthOriginal - 1) +\n                        (${dType}(xResized) * ${dType}(roiEnd - roiStart) * ${dType}(lengthOriginal - 1)) /\n                        ${dType}(lengthResized - 1);\n                  } else {\n                    return 0.5 * ${dType}(roiStart + roiEnd) * ${dType}(lengthOriginal - 1);\n                  }`;\n      case 'half_pixel_symmetric':\n        return `const outputWidth = ${dType}xScale * ${dType}(lengthResized);\n                  const adjustment = ${dType}(lengthResized) / outputWidth;\n                  const center = ${dType}(lengthOriginal) / 2;\n                  const offset = center * (1 - adjustment);\n                  return offset + ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`;\n      case 'half_pixel':\n        return `return ((${dType}(xResized) + 0.5) / ${dType}(xScale)) - 0.5;`;\n      default:\n        throw new Error(`Coordinate transform mode ${coordinateTransferMode} is not supported`);\n    }\n  })() +\n  '}';\n\nconst getNearestPixelFromOriginal = (nearestMode: NearestMode, opsetVersion: number, dType: string): string =>\n  `fn getNearestPixelFromOriginal(xOriginal: ${dType}, isDownSample: bool) -> ${dType} {` +\n  (() => {\n    switch (nearestMode) {\n      case 'round_prefer_ceil':\n        return 'if (fract(xOriginal) == 0.5) { \\\n            return ceil(xOriginal); \\\n          } else { \\\n            return round(xOriginal); \\\n          }';\n      case 'floor':\n        return 'return floor(xOriginal);';\n      case 'ceil':\n        return 'return ceil(xOriginal);';\n      case 'round_prefer_floor':\n        return 'if (fract(xOriginal) == 0.5) { \\\n                    return floor(xOriginal); \\\n                  } else { \\\n                    return round(xOriginal); \\\n                  }';\n      case 'simple':\n      default:\n        if (opsetVersion < 11) {\n          return 'if (isDownSample) \\\n                    { \\\n                      return ceil(xOriginal); \\\n                    } else { \\\n                      return xOriginal; \\\n                    }';\n        }\n        throw new Error(`Nearest mode ${nearestMode} is not supported`);\n    }\n  })() +\n  '}';\n\nconst updateRoI = (roi: readonly number[], axes: readonly number[], rank: number): number[] => {\n  const roiTmp = new Array(rank).fill(0).concat(new Array(rank).fill(1));\n  const roiLocal = roi.length === 0 ? roiTmp : roi.slice();\n  if (axes.length > 0) {\n    axes.forEach((v, i) => {\n      roiTmp[v] = roiLocal[i];\n      roiTmp[i + rank] = roiLocal[axes.length + i];\n    });\n    return roiTmp;\n  }\n  return roiLocal;\n};\n\nconst initOutputShape = (\n  inputShape: readonly number[],\n  scales: readonly number[],\n  sizes: readonly number[],\n  axes: readonly number[],\n): number[] => {\n  let outputShape: number[] = [];\n  if (sizes.length > 0) {\n    if (axes.length > 0) {\n      inputShape.forEach((v) => outputShape.push(v));\n      if (Math.max(...axes) > inputShape.length) {\n        throw new Error('axes is out of bound');\n      }\n      axes.forEach((v, i) => (outputShape[v] = sizes[i]));\n    } else {\n      sizes.forEach((v) => outputShape.push(v));\n    }\n  } else {\n    if (scales.length === 0) {\n      throw new Error('Resize requires either scales or sizes.');\n    } else {\n      outputShape = inputShape.map((value, index) => Math.round(value * scales[index]));\n    }\n  }\n  return outputShape;\n};\n\nconst adjustOutputShape = (inputShape: readonly number[], scales: number[], attributes: ResizeAttributes) => {\n  const scaleInPolicy = (() => {\n    switch (attributes.keepAspectRatioPolicy) {\n      case 'not_larger':\n        return attributes.axes.length > 0\n          ? Math.min(...attributes.axes.map((i) => scales[i]), Number.MAX_VALUE)\n          : Math.min(...scales, Number.MAX_VALUE);\n      case 'not_smaller':\n        return attributes.axes.length > 0\n          ? Math.max(...attributes.axes.map((i) => scales[i]), Number.MIN_VALUE)\n          : Math.max(...scales, Number.MIN_VALUE);\n      default:\n        throw new Error(`Keep aspect ratio policy ${attributes.keepAspectRatioPolicy} is not supported`);\n    }\n  })();\n  scales.fill(1.0, 0, scales.length);\n  const adjustedOutputShape = inputShape.slice();\n  if (attributes.axes.length > 0) {\n    attributes.axes.forEach((v) => (scales[v] = scaleInPolicy));\n    attributes.axes.forEach((v) => (adjustedOutputShape[v] = Math.round(inputShape[v] * scales[v])));\n  } else {\n    scales.fill(scaleInPolicy, 0, scales.length);\n    adjustedOutputShape.forEach((v, i) => (adjustedOutputShape[i] = Math.round(v * scales[i])));\n  }\n  return adjustedOutputShape;\n};\n\nconst calculateOriginalIndicesFromOutputIndices = (\n  output: IndicesHelper,\n  inputShape: readonly number[],\n  outputShape: readonly number[],\n  scalesLength: number,\n  roiLength: number,\n): string => `\n    fn calculateOriginalIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> array<${\n      output.type.value\n    }, ${outputShape.length}> {\n      var original_indices: array<${output.type.value}, ${outputShape.length}>;\n      for (var i:u32 = 0; i < ${outputShape.length}; i++) {\n        var output_index = ${output.indicesGet('output_indices', 'i')};\n        var scale = ${getElementAt('uniforms.scales', 'i', scalesLength)};\n        var roi_low = ${getElementAt('uniforms.roi', 'i', roiLength)};\n        var roi_hi = ${getElementAt('uniforms.roi', `i + ${inputShape.length}`, roiLength)};\n        if (scale == 1.0) {\n          original_indices[i] = ${output.type.value}(output_index);\n        } else {\n          var input_shape_i = ${getElementAt('uniforms.input_shape', 'i', inputShape.length)};\n          var output_shape_i = ${getElementAt('uniforms.output_shape', 'i', outputShape.length)};\n          original_indices[i] = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,\n                                                                           input_shape_i, roi_low, roi_hi);\n        }\n      }\n      return original_indices;\n    }`;\n\nconst calculateInputIndicesFromOutputIndices = (\n  input: IndicesHelper,\n  output: IndicesHelper,\n  inputShape: readonly number[],\n  outputShape: readonly number[],\n  scalesLength: number,\n  roiLength: number,\n  useExtrapolation: boolean,\n): string => `\n    fn calculateInputIndicesFromOutputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} {\n      var input_indices: ${input.type.indices};\n      for (var i:u32 = 0; i < ${outputShape.length}; i++) {\n        var output_index = ${output.indicesGet('output_indices', 'i')};\n        var input_index: u32;\n        var scale = ${getElementAt('uniforms.scales', 'i', scalesLength)};\n        if (scale == 1.0) {\n          input_index = output_index;\n        } else {\n          var roi_low = ${getElementAt('uniforms.roi', 'i', roiLength)};\n          var roi_hi = ${getElementAt('uniforms.roi', `i + ${inputShape.length}`, roiLength)};\n          var input_shape_i = ${getElementAt('uniforms.input_shape', 'i', inputShape.length)};\n          var output_shape_i = ${getElementAt('uniforms.output_shape', 'i', outputShape.length)};\n          var original_idx = getOriginalCoordinateFromResizedCoordinate(output_index, scale, output_shape_i,\n                                                                        input_shape_i, roi_low, roi_hi);\n          if (!${useExtrapolation} || (original_idx >= 0 && original_idx < ${output.type.value}(input_shape_i))) {\n            if (original_idx < 0) {\n              input_index = 0;\n            } else if (original_idx > ${output.type.value}(input_shape_i - 1)) {\n              input_index = input_shape_i - 1;\n            } else {\n              input_index = u32(getNearestPixelFromOriginal(original_idx, scale < 1));\n            }\n          } else {\n            input_index = u32(original_idx);\n          }\n        }\n        ${input.indicesSet('input_indices', 'i', 'input_index')}\n      }\n      return input_indices;\n    }`;\nconst checkInputIndices = (input: IndicesHelper, inputShape: readonly number[]): string => `\n    fn checkInputIndices(input_indices: ${input.type.indices}) -> bool {\n      for (var i:u32 = 0; i < ${inputShape.length}; i++) {\n        var input_index = ${input.indicesGet('input_indices', 'i')};\n        if (input_index < 0 || input_index >= ${getElementAt('uniforms.input_shape', 'i', inputShape.length)}) {\n          return false;\n        }\n      }\n      return true;\n    }`;\n\nconst setChannelAndBatchIndices = (\n  input: IndicesHelper,\n  channelIdx: number,\n  batchIdx: number,\n  spacialDims: number,\n): string =>\n  input.rank > spacialDims\n    ? `\n    ${input.indicesSet('input_indices', channelIdx, 'channel')};\n    ${input.indicesSet('input_indices', batchIdx, 'batch')};\n`\n    : '';\n\nconst bilinearInterpolation = (\n  input: IndicesHelper,\n  output: IndicesHelper,\n  inputShape: readonly number[],\n  useExtrapolation: boolean,\n  extrapolationValue: number,\n): string => {\n  const isNchw = true;\n  const [batchIdx, heightIdx, widthIdx, channelIdx] =\n    inputShape.length === 2 ? [-1, 0, 1, -1] : isNchw ? [0, 2, 3, 1] : [0, 1, 2, 3];\n  const dType = input.type.value;\n  return `\n    fn getInputValue(batch: u32, channel: u32, row: u32, col: u32) -> ${dType} {\n      var input_indices: ${input.type.indices};\n      ${input.indicesSet('input_indices', heightIdx, `max(0, min(row, ${inputShape[heightIdx]} - 1))`)};\n      ${input.indicesSet('input_indices', widthIdx, `max(0, min(col, ${inputShape[widthIdx]} - 1))`)};\n      ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 2)}\n      return ${input.getByIndices('input_indices')};\n    }\n\n    fn bilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n      var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);\n      var row:${dType} = originalIndices[${heightIdx}];\n      var col:${dType} = originalIndices[${widthIdx}];\n      ${\n        useExtrapolation\n          ? `if (row < 0 || row > (${inputShape[heightIdx]} - 1) || col < 0 || col > (${inputShape[widthIdx]} - 1)) {\n        return ${extrapolationValue};\n      }`\n          : ''\n      };\n      row = max(0, min(row, ${inputShape[heightIdx]} - 1));\n      col = max(0, min(col, ${inputShape[widthIdx]} - 1));\n      var row1: u32 = u32(row);\n      var col1: u32 = u32(col);\n      var row2: u32 = u32(row + 1);\n      var col2: u32 = u32(col + 1);\n      var channel: u32 = ${inputShape.length > 2 ? `u32(originalIndices[${channelIdx}])` : '0'};\n      var batch: u32 =  ${inputShape.length > 2 ? `u32(originalIndices[${batchIdx}])` : '0'};\n      var x11: ${dType} = getInputValue(batch, channel, row1, col1);\n      var x12: ${dType} = getInputValue(batch, channel, row1, col2);\n      var x21: ${dType} = getInputValue(batch, channel, row2, col1);\n      var x22: ${dType} = getInputValue(batch, channel, row2, col2);\n      var dx1: ${dType} = abs(row - ${dType}(row1));\n      var dx2: ${dType} = abs(${dType}(row2) - row);\n      var dy1: ${dType} = abs(col - ${dType}(col1));\n      var dy2: ${dType} = abs(${dType}(col2) - col);\n      if (row1 == row2) {\n        dx1 = 0.5;\n        dx2 = 0.5;\n      }\n      if (col1 == col2) {\n        dy1 = 0.5;\n        dy2 = 0.5;\n      }\n      return (x11 * dx2 * dy2 + x12 * dx2 * dy1 + x21 * dx1 * dy2 + x22 * dx1 * dy1);\n    }`;\n};\n\nconst bicubicInterpolation = (\n  input: IndicesHelper,\n  output: IndicesHelper,\n  inputShape: readonly number[],\n  outputShape: readonly number[],\n  scales: readonly number[],\n  roi: readonly number[],\n  cubicCoeffA: number,\n  useExtrapolation: boolean,\n  extrapolationValue: number,\n  excludeOutside: boolean,\n): string => {\n  const is2D = inputShape.length === 2;\n  const isNchw = true;\n  const [heightIdx, widthIdx] = is2D ? [0, 1] : isNchw ? [2, 3] : [1, 2];\n  const dType = input.type.value;\n  const createCubicInterpolationFunction = (idx: number): string => {\n    const direction = idx === heightIdx ? 'row' : 'col';\n    return `\n      fn ${direction}CubicInterpolation(input_indices: ${input.type.indices}, output_indices: ${\n        output.type.indices\n      }) -> ${dType} {\n        var output_index = ${output.indicesGet('output_indices', idx)};\n        var originalIdx: ${dType} = getOriginalCoordinateFromResizedCoordinate(output_index, ${scales[idx]},\n        ${outputShape[idx]}, ${inputShape[idx]}, ${roi[idx]}, ${roi[idx]} + ${inputShape.length});\n        var fractOriginalIdx: ${dType} = originalIdx - floor(originalIdx);\n        var coefs = getCubicInterpolationCoefs(fractOriginalIdx);\n\n        if (${useExtrapolation} && (originalIdx < 0 || originalIdx > (${inputShape[idx]} - 1))) {\n          return ${extrapolationValue};\n        }\n        var data: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0);\n        for (var i: i32 = -1; i < 3; i++) {\n          var ${direction}: ${dType} = originalIdx + ${dType}(i);\n          if (${direction} < 0 || ${direction} >= ${inputShape[idx]}) {\n            ${(() => {\n              if (excludeOutside) {\n                return `coefs[i + 1] = 0.0;\n                        continue;`;\n              } else if (useExtrapolation) {\n                return `return ${extrapolationValue};`;\n              } else {\n                return `${direction} = max(0, min(${direction}, ${inputShape[idx]} - 1));`;\n              }\n            })()};\n          }\n        var input_indices_copy: ${input.type.indices} = input_indices;\n          ${input.indicesSet('input_indices_copy', idx, `u32(${direction})`)};\n          data[i + 1] = ${\n            idx === heightIdx\n              ? input.getByIndices('input_indices_copy')\n              : 'rowCubicInterpolation(input_indices_copy, output_indices)'\n          };\n        }\n        return cubicInterpolation1D(data, coefs);\n      }`;\n  };\n\n  return `\n    ${createCubicInterpolationFunction(heightIdx)};\n    ${createCubicInterpolationFunction(widthIdx)};\n  fn getCubicInterpolationCoefs(s: ${dType}) -> array<${dType}, 4> {\n    var absS = abs(s);\n    var coeffs: array<${dType}, 4> = array<${dType}, 4>(0.0, 0.0, 0.0, 0.0);\n    var oneMinusAbsS: ${dType} = 1.0 - absS;\n    var twoMinusAbsS: ${dType} = 2.0 - absS;\n    var onePlusAbsS: ${dType} = 1.0 + absS;\n    coeffs[0] = ((${cubicCoeffA} * onePlusAbsS - 5 * ${cubicCoeffA}) * onePlusAbsS + 8 * ${\n      cubicCoeffA\n    }) * onePlusAbsS - 4 * ${cubicCoeffA};\n    coeffs[1] = ((${cubicCoeffA} + 2) * absS - (${cubicCoeffA} + 3)) * absS * absS + 1;\n    coeffs[2] = ((${cubicCoeffA} + 2) * oneMinusAbsS - (${cubicCoeffA} + 3)) * oneMinusAbsS * oneMinusAbsS + 1;\n    coeffs[3] = ((${cubicCoeffA} * twoMinusAbsS - 5 * ${cubicCoeffA}) * twoMinusAbsS + 8 * ${\n      cubicCoeffA\n    }) * twoMinusAbsS - 4 * ${cubicCoeffA};\n    return coeffs;\n  }\n\n  fn cubicInterpolation1D(x: array<${dType}, 4>, coefs: array<${dType}, 4>) -> ${dType} {\n    var coefsSum: ${dType} = coefs[0] + coefs[1] + coefs[2] + coefs[3];\n    return (x[0] * coefs[0] + x[1] * coefs[1]+ x[2] * coefs[2]+ x[3] * coefs[3]) / coefsSum;\n  }\n\n  fn bicubicInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n    var input_indices: ${input.type.indices} = output_indices;\n    return colCubicInterpolation(input_indices, output_indices);\n  }\n    `;\n};\n\nconst trilinearInterpolation = (\n  input: IndicesHelper,\n  output: IndicesHelper,\n  inputShape: readonly number[],\n  useExtrapolation: boolean,\n  extrapolationValue: number,\n): string => {\n  const isNchw = true;\n  const [batchIdx, depthIdx, heightIdx, widthIdx, channelIdx] =\n    inputShape.length === 3 ? [-1, 0, 1, 2, -1] : isNchw ? [0, 2, 3, 4, 1] : [0, 1, 2, 3, 4];\n  const dType = input.type.value;\n  return `\n    fn getInputValue(batch: u32, channel: u32, depth:u32, height: u32, width: u32) -> ${dType} {\n      var input_indices: ${input.type.indices};\n      ${input.indicesSet('input_indices', depthIdx, `max(0, min(depth, ${inputShape[depthIdx]} - 1))`)};\n      ${input.indicesSet('input_indices', heightIdx, `max(0, min(height, ${inputShape[heightIdx]} - 1))`)};\n      ${input.indicesSet('input_indices', widthIdx, `max(0, min(width, ${inputShape[widthIdx]} - 1))`)};\n      ${setChannelAndBatchIndices(input, channelIdx, batchIdx, 3)}\n      return ${input.getByIndices('input_indices')};\n    }\n\n    fn trilinearInterpolation(output_indices: ${output.type.indices}) -> ${dType} {\n      var originalIndices = calculateOriginalIndicesFromOutputIndices(output_indices);\n      var depth:${dType} = originalIndices[${depthIdx}];\n      var height:${dType} = originalIndices[${heightIdx}];\n      var width:${dType} = originalIndices[${widthIdx}];\n      ${\n        useExtrapolation\n          ? `if (depth < 0 || depth > (${inputShape[depthIdx]} - 1) || height < 0 || height > (${\n              inputShape[heightIdx]\n            } - 1) || width < 0 || (width > ${inputShape[widthIdx]} - 1)) {\n      return ${extrapolationValue};\n        }`\n          : ''\n      };\n\n    depth = max(0, min(depth, ${inputShape[depthIdx]} - 1));\n      height = max(0, min(height, ${inputShape[heightIdx]} - 1));\n      width = max(0, min(width, ${inputShape[widthIdx]} - 1));\n      var depth1: u32 = u32(depth);\n      var height1: u32 = u32(height);\n      var width1: u32 = u32(width);\n      var depth2: u32 = u32(depth + 1);\n      var height2: u32 = u32(height + 1);\n      var width2: u32 = u32(width + 1);\n      var channel: u32 = ${inputShape.length > 3 ? `u32(originalIndices[${channelIdx}])` : '0'};\n      var batch: u32 =  ${inputShape.length > 3 ? `u32(originalIndices[${batchIdx}])` : '0'};\n\n      var x111: ${dType} = getInputValue(batch, channel, depth1, height1, width1);\n      var x112: ${dType} = getInputValue(batch, channel, depth1, height1, width2);\n      var x121: ${dType} = getInputValue(batch, channel, depth1, height2, width1);\n      var x122: ${dType} = getInputValue(batch, channel, depth1, height2, width2);\n      var x211: ${dType} = getInputValue(batch, channel, depth2, height1, width1);\n      var x212: ${dType} = getInputValue(batch, channel, depth2, height1, width2);\n      var x221: ${dType} = getInputValue(batch, channel, depth2, height2, width1);\n      var x222: ${dType} = getInputValue(batch, channel, depth2, height2, width2);\n      var dx1: ${dType} = abs(depth - ${dType}(depth1));\n      var dx2: ${dType} = abs(${dType}(depth2) - depth);\n      var dy1: ${dType} = abs(height - ${dType}(height1));\n      var dy2: ${dType} = abs(${dType}(height2) - height);\n      var dz1: ${dType} = abs(width - ${dType}(width1));\n      var dz2: ${dType} = abs(${dType}(width2) - width);\n      if (depth1 == depth2) {\n        dx1 = 0.5;\n        dx2 = 0.5;\n      }\n      if (height1 == height2) {\n        dy1 = 0.5;\n        dy2 = 0.5;\n      }\n      if (width1 == width2) {\n        dz1 = 0.5;\n        dz2 = 0.5;\n      }\n      return (x111 * dx2 * dy2 * dz2 + x112 * dx2 * dy2 * dz1 + x121 * dx2 * dy1 *dz2 + x122 * dx2 * dy1 * dz1 +\n              x211 * dx1 * dy2 * dz2 + x212 * dx1 * dy2 * dz1 + x221 * dx1 * dy1 *dz2 + x222 * dx1 * dy1 * dz1);\n    }`;\n};\n\nconst createResizeProgramInfo = (\n  inputTensor: TensorView,\n  attributes: ResizeAttributes,\n  opsetVersion: number,\n  scalesInput: readonly number[],\n  sizes: readonly number[],\n  roiInput: readonly number[],\n): ProgramInfo => {\n  const inputShape = inputTensor.dims;\n  const roi = updateRoI(roiInput, attributes.axes, inputShape.length);\n\n  let outputShape = initOutputShape(inputShape, scalesInput, sizes, attributes.axes);\n  let scales = scalesInput.slice();\n  if (scalesInput.length === 0) {\n    scales = inputShape.map((value, index) => (value === 0 ? 1.0 : outputShape[index] / value));\n    if (attributes.keepAspectRatioPolicy !== 'stretch') {\n      outputShape = adjustOutputShape(inputShape, scales, attributes);\n    }\n  }\n  const output = outputVariable('output', inputTensor.dataType, outputShape.length);\n  const input = inputVariable('input', inputTensor.dataType, inputShape.length);\n  const outputSize = ShapeUtil.size(outputShape);\n  const noScale = inputShape.length === outputShape.length && inputShape.every((d, i) => d === outputShape[i]);\n  const useExtrapolation = attributes.coordinateTransformMode === 'tf_crop_and_resize';\n  const extrapolationValue = attributes.extrapolationValue;\n  const dataType = input.type.value;\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n      ${\n        noScale\n          ? ''\n          : `\n      ${getOriginalCoordinateFromResizedCoordinate(attributes.coordinateTransformMode, dataType)};\n      ${(() => {\n        switch (attributes.mode) {\n          case 'nearest':\n            return `\n              ${checkInputIndices(input, inputShape)};\n              ${getNearestPixelFromOriginal(attributes.nearestMode, opsetVersion, dataType)};\n              ${calculateInputIndicesFromOutputIndices(\n                input,\n                output,\n                inputShape,\n                outputShape,\n                scales.length,\n                roi.length,\n                useExtrapolation,\n              )};\n              `;\n          case 'linear':\n            return `\n              ${calculateOriginalIndicesFromOutputIndices(output, inputShape, outputShape, scales.length, roi.length)};\n              ${(() => {\n                if (inputShape.length === 2 || inputShape.length === 4) {\n                  return `${bilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`;\n                } else if (inputShape.length === 3 || inputShape.length === 5) {\n                  return `${trilinearInterpolation(input, output, inputShape, useExtrapolation, extrapolationValue)}`;\n                } else {\n                  throw Error('Linear mode only supports input dims 2, 3, 4 and 5 are supported in linear mode.');\n                }\n              })()};\n            `;\n          case 'cubic':\n            return `\n            ${(() => {\n              if (inputShape.length === 2 || inputShape.length === 4) {\n                return `${bicubicInterpolation(\n                  input,\n                  output,\n                  inputShape,\n                  outputShape,\n                  scales,\n                  roi,\n                  attributes.cubicCoeffA,\n                  useExtrapolation,\n                  attributes.extrapolationValue,\n                  attributes.excludeOutside,\n                )}`;\n              } else {\n                throw Error('Cubic mode only supports input dims 2 and 4 are supported in linear mode.');\n              }\n            })()};\n            `;\n          default:\n            throw Error('Invalid resize mode');\n        }\n      })()};\n      `\n      }\n      ${shaderHelper\n        .registerUniform('output_size', 'u32')\n        .registerUniform('scales', 'f32', scales.length)\n        .registerUniform('roi', 'f32', roi.length)\n        .declareVariables(input, output)}\n      ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n        ${\n          noScale\n            ? 'output[global_idx] = input[global_idx];'\n            : `\n        let output_indices = ${output.offsetToIndices('global_idx')};\n        var input_indices: ${input.type.indices};\n        ${(() => {\n          switch (attributes.mode) {\n            case 'nearest':\n              return `input_indices = calculateInputIndicesFromOutputIndices(output_indices);\n                if (checkInputIndices(input_indices)) {\n                  output[global_idx] = ${input.getByIndices('input_indices')};\n                } else {\n                  output[global_idx] = ${attributes.extrapolationValue};\n                }`;\n            case 'linear':\n              return `output[global_idx] = ${\n                inputShape.length === 2 || inputShape.length === 4 ? 'bilinearInterpolation' : 'trilinearInterpolation'\n              }(output_indices);`;\n            case 'cubic':\n              return 'output[global_idx] = bicubicInterpolation(output_indices);';\n            default:\n              throw Error(`Unsupported resize mode: ${attributes.mode}`);\n          }\n        })()};\n`\n        }\n      }`;\n\n  return {\n    name: 'Resize',\n    shaderCache: {\n      hint: `${attributes.cacheKey}|${opsetVersion}|${\n        scales.length > 0 ? (attributes.mode === 'cubic' ? scales : scales.length) : ''\n      }|${sizes.length > 0 ? sizes : ''}|${roi.length > 0 ? roi : ''}|${noScale}|${\n        attributes.mode === 'nearest' ? inputShape.length : inputShape\n      }`,\n      inputDependencies: ['rank'],\n    },\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: inputTensor.dataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms: [\n        { type: DataType.uint32, data: outputSize },\n        { type: DataType.float, data: scales },\n        { type: DataType.float, data: roi },\n        ...createTensorShapeVariables(inputShape, outputShape),\n      ],\n    }),\n  };\n};\n\nconst getOpsetVersionFromCustomDataBuffer = (context: ComputeContext): number => {\n  const customDataBuffer = context.customDataBuffer;\n  const customDataBuffer32 = new Uint32Array(customDataBuffer, customDataBuffer.byteOffset, 1);\n  const opsetVersion = customDataBuffer32[0];\n  return opsetVersion;\n};\n\nexport const resize = (context: ComputeContext, attributes: ResizeAttributes): void => {\n  const scales: number[] = [];\n  const sizes: number[] = [];\n  const roi: number[] = [];\n\n  // Note that scales in resize are always f32. roi can be f32 or f16.\n  // TODO: Currently this code does not support f16 for roi when passed as optional input.\n\n  const opsetVersion = getOpsetVersionFromCustomDataBuffer(context);\n  if (attributes.antialias !== 0) {\n    throw Error('Only default value (0) for Antialias attribute is supported');\n  }\n  validateInputs(context.inputs, attributes, opsetVersion, scales, sizes, roi);\n  context.compute(createResizeProgramInfo(context.inputs[0], attributes, opsetVersion, scales, sizes, roi), {\n    inputs: [0],\n  });\n};\n\nexport const parseResizeAttributes = (attributes: Record<string, unknown>): ResizeAttributes => {\n  const antialias = attributes.antialias as number;\n  const axes = attributes.axes as number[];\n  const coordinateTransformMode: CoordinateTransformMode =\n    attributes.coordinateTransformMode as CoordinateTransformMode;\n  const cubicCoeffA = attributes.cubicCoeffA as number;\n  const excludeOutside = (attributes.excludeOutside as number) !== 0;\n  const extrapolationValue = attributes.extrapolationValue as number;\n  const keepAspectRatioPolicy: KeepAspectRatioPolicy = attributes.keepAspectRatioPolicy as KeepAspectRatioPolicy;\n  const mode: Mode = attributes.mode as Mode;\n  // If nearestMode is not specified, use simple mode.\n  const nearestMode: NearestMode = (attributes.nearestMode === '' ? 'simple' : attributes.nearestMode) as NearestMode;\n  return createAttributeWithCacheKey({\n    antialias,\n    axes,\n    coordinateTransformMode,\n    cubicCoeffA,\n    excludeOutside,\n    extrapolationValue,\n    keepAspectRatioPolicy,\n    mode,\n    nearestMode,\n  });\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { ComputeContext, ProgramInfo, ProgramUniform } from '../types';\n\nimport {\n  castToF32,\n  getMaxComponents,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  sumVector,\n  tensorTypeToWsglStorageType,\n  UniformsArrayType,\n} from './common';\n\nexport interface SkipLayerNormAttributes {\n  simplified: boolean;\n  epsilon: number;\n}\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length < 3) {\n    throw new Error('layerNorm requires at least 3 inputs.');\n  }\n\n  const input: TensorView = inputs[0];\n  const skip: TensorView = inputs[1];\n  const gamma: TensorView = inputs[2];\n\n  if (input.dataType !== skip.dataType || input.dataType !== gamma.dataType) {\n    throw new Error('All inputs must have the same data type');\n  }\n\n  if (input.dims.length !== 3 && input.dims.length !== 2) {\n    throw new Error('Input must be 2D or 3D');\n  }\n\n  if (skip.dims.length !== 3 && skip.dims.length !== 2) {\n    throw new Error('Skip must be 2D or 3D');\n  }\n\n  const hiddenSize = input.dims[input.dims.length - 1];\n  const sequenceLength = input.dims[input.dims.length - 2];\n  if (skip.dims[skip.dims.length - 1] !== hiddenSize) {\n    throw new Error('Skip must have the same hidden size as input');\n  }\n  if (skip.dims[skip.dims.length - 2] !== sequenceLength) {\n    throw new Error('Skip must have the same sequence length as input');\n  }\n\n  if (gamma.dims.length !== 1) {\n    throw new Error('Gamma must be 1D');\n  }\n  if (gamma.dims[gamma.dims.length - 1] !== hiddenSize) {\n    throw new Error('Gamma must have the same hidden size as input');\n  }\n  if (inputs.length > 3) {\n    const beta: TensorView = inputs[3];\n    if (beta.dims.length !== 1) {\n      throw new Error('Beta must be 1D');\n    }\n    if (beta.dims[beta.dims.length - 1] !== hiddenSize) {\n      throw new Error('Beta must have the same hidden size as input');\n    }\n  }\n  if (inputs.length > 4) {\n    const bias: TensorView = inputs[4];\n    if (bias.dims.length !== 1) {\n      throw new Error('Bias must be 1D');\n    }\n    if (bias.dims[bias.dims.length - 1] !== hiddenSize) {\n      throw new Error('Bias must have the same hidden size as input');\n    }\n  }\n};\n\nconst createSkipLayerNormProgramInfo = (\n  inputs: readonly TensorView[],\n  attributes: SkipLayerNormAttributes,\n  outputCount: number,\n  isTraining: boolean,\n): ProgramInfo => {\n  const simplified = attributes.simplified;\n\n  const inputShape = inputs[0].dims;\n  const inputSize = ShapeUtil.size(inputShape);\n  const outputShape = inputShape;\n  const outputSize = inputSize;\n  const hiddenSize = inputShape.slice(-1)[0];\n  const meanInvStdDevDim = isTraining ? inputShape.slice(0, -1).concat(1) : [];\n  const hasBetaInput = !simplified && inputs.length > 3;\n  const hasBiasInput = inputs.length > 4;\n  const hasMeanOutput = isTraining && outputCount > 1;\n  const hasInvStdDevOutput = isTraining && outputCount > 2;\n  const hasInputSkipBiasSumOutput = outputCount > 3;\n  const workgroupSize = 64;\n\n  const components = getMaxComponents(hiddenSize);\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.uint32, data: components },\n    { type: DataType.uint32, data: hiddenSize },\n    { type: DataType.float, data: attributes.epsilon },\n  ];\n  const getShaderSource = (shaderHelper: ShaderHelper) => {\n    const uniformsArray: UniformsArrayType = [\n      { name: 'output_size', type: 'u32' },\n      { name: 'components', type: 'u32' },\n      { name: 'hidden_size', type: 'u32' },\n      { name: 'epsilon', type: 'f32' },\n    ];\n    const variables = [\n      inputVariable('x', inputs[0].dataType, inputs[0].dims, components),\n      inputVariable('skip', inputs[1].dataType, inputs[1].dims, components),\n      inputVariable('gamma', inputs[2].dataType, inputs[2].dims, components),\n    ];\n    if (hasBetaInput) {\n      variables.push(inputVariable('beta', inputs[3].dataType, inputs[3].dims, components));\n    }\n    if (hasBiasInput) {\n      variables.push(inputVariable('bias', inputs[4].dataType, inputs[4].dims, components));\n    }\n    variables.push(outputVariable('output', inputs[0].dataType, outputShape, components));\n    if (hasMeanOutput) {\n      variables.push(outputVariable('mean_output', DataType.float, meanInvStdDevDim));\n    }\n    if (hasInvStdDevOutput) {\n      variables.push(outputVariable('inv_std_output', DataType.float, meanInvStdDevDim));\n    }\n    if (hasInputSkipBiasSumOutput) {\n      variables.push(outputVariable('input_skip_bias_sum', inputs[0].dataType, outputShape, components));\n    }\n    const dataType = tensorTypeToWsglStorageType(inputs[0].dataType);\n    const vecDataType = tensorTypeToWsglStorageType(DataType.float, components);\n    return `\n\n      ${shaderHelper.registerUniforms(uniformsArray).declareVariables(...variables)}\n      var<workgroup> sum_shared : array<${vecDataType}, ${workgroupSize}>;\n      var<workgroup> sum_squared_shared : array<${vecDataType}, ${workgroupSize}>;\n\n      ${shaderHelper.mainStart([workgroupSize, 1, 1])}\n        let ix = local_id.x;\n        let iy = global_id.x / ${workgroupSize};\n\n        let hidden_size_vectorized: u32 = uniforms.hidden_size / uniforms.components;\n        var stride = hidden_size_vectorized / ${workgroupSize};\n        let offset = ix * stride + iy * hidden_size_vectorized;\n        let offset1d = stride * ix;\n        if (ix == ${workgroupSize - 1}) {\n          stride = hidden_size_vectorized - stride * ix;\n        }\n        for (var i: u32 = 0; i < stride; i++) {\n          let skip_value = skip[offset + i];\n          let bias_value = ${hasBiasInput ? 'bias[offset1d + i]' : dataType + '(0.0)'};\n          let input_value = x[offset + i];\n          let value = input_value + skip_value + bias_value;\n          ${hasInputSkipBiasSumOutput ? 'input_skip_bias_sum[offset + i] = value;' : ''}\n          output[offset + i] = value;\n          let f32_value = ${castToF32(dataType, components, 'value')};\n          sum_shared[ix] += f32_value;\n          sum_squared_shared[ix] += f32_value * f32_value;\n        }\n        workgroupBarrier();\n\n        var reduce_size : u32 = ${workgroupSize};\n        for (var curr_size = reduce_size >> 1;  curr_size > 0; curr_size = reduce_size >> 1) {\n          reduce_size = curr_size + (reduce_size & 1);\n          if (ix < curr_size) {\n            sum_shared[ix] += sum_shared[ix + reduce_size];\n            sum_squared_shared[ix] += sum_squared_shared[ix + reduce_size];\n          }\n          workgroupBarrier();\n        }\n\n        let sum = sum_shared[0];\n        let square_sum = sum_squared_shared[0];\n        let mean = ${sumVector('sum', components)} / f32(uniforms.hidden_size);\n        let inv_std_dev = inverseSqrt(${sumVector('square_sum', components)} / f32(uniforms.hidden_size) ${\n          simplified ? '' : '- mean * mean'\n        } + uniforms.epsilon);\n        ${hasMeanOutput ? 'mean_output[global_idx] = mean;' : ''}\n        ${hasInvStdDevOutput ? 'inv_std_output[global_idx] = inv_std_dev;' : ''}\n\n        for (var i: u32 = 0; i < stride; i++) {\n          output[offset + i] = (output[offset + i] ${simplified ? '' : `- ${dataType}(mean)`}) *\n            ${dataType}(inv_std_dev) * gamma[offset1d + i]\n            ${hasBetaInput ? '+ beta[offset1d + i]' : ''};\n        }\n      }`;\n  };\n  const outputs = [{ dims: outputShape, dataType: inputs[0].dataType }];\n  if (outputCount > 1) {\n    outputs.push({ dims: meanInvStdDevDim, dataType: DataType.float });\n  }\n  if (outputCount > 2) {\n    outputs.push({ dims: meanInvStdDevDim, dataType: DataType.float });\n  }\n  if (outputCount > 3) {\n    outputs.push({ dims: inputShape, dataType: inputs[0].dataType });\n  }\n  return {\n    name: 'SkipLayerNormalization',\n    shaderCache: {\n      hint: `${components};${hasMeanOutput};${hasInvStdDevOutput};${hasInputSkipBiasSumOutput}`,\n      inputDependencies: inputs.map((_input, _index) => 'type'),\n    },\n    getShaderSource,\n    getRunData: () => ({\n      outputs,\n      dispatchGroup: {\n        x: Math.ceil(outputSize / hiddenSize),\n      },\n      programUniforms,\n    }),\n  };\n};\n\nexport const skipLayerNorm = (context: ComputeContext, attributes: SkipLayerNormAttributes): void => {\n  // TODO: initialize isTraining from ComputeContext\n  const isTraining = false;\n  validateInputs(context.inputs);\n  // Mean and InvStdDev are only used in training mode and are not required for inference.\n  // They are added here for completeness only.\n  const outputs = [0];\n  if (context.outputCount > 1) {\n    outputs.push(isTraining ? 1 : -3);\n  }\n  if (context.outputCount > 2) {\n    outputs.push(isTraining ? 2 : -3);\n  }\n  if (context.outputCount > 3) {\n    outputs.push(3);\n  }\n  context.compute(createSkipLayerNormProgramInfo(context.inputs, attributes, context.outputCount, isTraining), {\n    outputs,\n  });\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext, ProgramInfo, ProgramUniform, TensorInfo } from '../types';\n\nimport {\n  createTensorShapeVariables,\n  getElementAt,\n  IndicesHelper,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  UniformsArrayType,\n} from './common';\n\nexport interface SliceAttributes extends AttributeWithCacheKey {\n  readonly starts: number[];\n  readonly ends: number[];\n  readonly axes: number[];\n}\n\nconst validateInputs = (inputs: readonly TensorView[], attributes: SliceAttributes): void => {\n  if (!inputs || inputs.length < 1) {\n    throw new Error('too few inputs');\n  }\n  if (attributes.axes.length !== 0) {\n    if (attributes.axes.length !== attributes.starts.length || attributes.axes.length !== attributes.ends.length) {\n      throw new Error('axes, starts and ends must have the same length');\n    }\n  } else if (attributes.starts.length !== attributes.ends.length) {\n    throw new Error('starts and ends must have the same length');\n  }\n  inputs.slice(1).forEach((_, idx) => {\n    if (inputs[idx + 1].dataType !== DataType.int32 && inputs[idx + 1].dataType !== DataType.int64) {\n      throw new Error(`Input ${idx} must be an array of int32 or int64`);\n    }\n  });\n};\n\nconst readInput = (inputs: readonly TensorView[], idx: number): number[] => {\n  const input: number[] = [];\n  if (inputs.length > idx) {\n    if (inputs[idx].dataType === DataType.int64) {\n      inputs[idx].getBigInt64Array().forEach((v) => input.push(Number(v)));\n    } else if (inputs[idx].dataType === DataType.int32) {\n      inputs[idx].getInt32Array().forEach((v) => input.push(Number(v)));\n    } else {\n      throw new Error(`Input ${idx} must be an array of int32 or int64`);\n    }\n  }\n  return input;\n};\n\nconst createSliceAttributesFromInputs = (\n  inputs: readonly TensorView[],\n  attributes: SliceAttributes,\n): SliceAttributes => {\n  if (inputs.length > 1) {\n    const starts: number[] = readInput(inputs, 1);\n    const ends: number[] = readInput(inputs, 2);\n    let axes: number[] = readInput(inputs, 3);\n    if (axes.length === 0) {\n      axes = [...Array(inputs[0].dims.length).keys()];\n    }\n    return createAttributeWithCacheKey({ starts, ends, axes });\n  } else {\n    return attributes;\n  }\n};\n\nconst fixStartEndValues = (\n  value: number,\n  index: number,\n  inputShape: readonly number[],\n  axes: readonly number[],\n  steps: readonly number[],\n): number => {\n  let newValue = value;\n  if (value < 0) {\n    newValue += inputShape[axes[index]];\n  }\n  if (steps[index] < 0) {\n    return Math.max(0, Math.min(newValue, inputShape[axes[index]] - 1));\n  } else {\n    return Math.max(0, Math.min(newValue, inputShape[axes[index]]));\n  }\n};\n\nconst calculateInputIndicesImpl = (\n  input: IndicesHelper,\n  output: IndicesHelper,\n  inputShape: readonly number[],\n): string =>\n  `fn calculateInputIndices(output_indices: ${output.type.indices}) -> ${input.type.indices} {\n          var input_indices: ${input.type.indices};\n          var carry = 0u;\n          for (var i = ${inputShape.length - 1}; i >= 0; i--) {\n            let input_shape_i = ${getElementAt('uniforms.input_shape', 'i', inputShape.length)};\n            let steps_i = ${getElementAt('uniforms.steps', 'i', inputShape.length)};\n            let signs_i = ${getElementAt('uniforms.signs', 'i', inputShape.length)};\n            let starts_i = ${getElementAt('uniforms.starts', 'i', inputShape.length)};\n            var output_index = ${output.indicesGet('output_indices', 'i')};\n            var input_index = output_index * steps_i + starts_i + carry;\n            carry = input_index / input_shape_i;\n            input_index = input_index % input_shape_i;\n            if (signs_i < 0) {\n              input_index = input_shape_i - input_index - 1u + starts_i;\n            }\n            ${input.indicesSet('input_indices', 'i', 'input_index')};\n          }\n          return input_indices;\n      }`;\n\nconst createSliceProgramInfo = (inputs: readonly TensorView[], attributes: SliceAttributes): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const inputSize = ShapeUtil.size(inputShape);\n  const axes =\n    attributes.axes.length > 0\n      ? ShapeUtil.normalizeAxes(attributes.axes, inputShape.length)\n      : [...Array(inputShape.length).keys()];\n  let steps = readInput(inputs, 4);\n  steps.forEach(\n    (step) =>\n      step !== 0 ||\n      (() => {\n        throw new Error('step cannot be 0');\n      }),\n  );\n  if (steps.length === 0) {\n    steps = Array(axes.length).fill(1);\n  }\n  const starts = attributes.starts.map((start, i) => fixStartEndValues(start, i, inputShape, axes, steps));\n\n  const ends = attributes.ends.map((end, i) => fixStartEndValues(end, i, inputShape, axes, steps));\n\n  if (axes.length !== starts.length || axes.length !== ends.length) {\n    throw new Error('start, ends and axes should have the same number of elements');\n  }\n\n  if (axes.length !== inputShape.length) {\n    for (let i = 0; i < inputShape.length; ++i) {\n      if (!axes.includes(i)) {\n        starts.splice(i, 0, 0);\n        ends.splice(i, 0, inputShape[i]);\n        steps.splice(i, 0, 1);\n      }\n    }\n  }\n  const signs = steps.map((step) => Math.sign(step));\n  // Convert negative steps to positive steps and reverse starts and ends\n  steps.forEach((step, i, array) => {\n    if (step < 0) {\n      const numSteps = (ends[i] - starts[i]) / step;\n      const newEnd = starts[i];\n      const newStart = newEnd + numSteps * steps[i];\n      starts[i] = newStart;\n      ends[i] = newEnd;\n      array[i] = -step;\n    }\n  });\n  // Output rank is expected to be less than or equal to the input rank.\n  const outputShape = inputShape.slice(0);\n  axes.forEach((axis, _) => {\n    outputShape[axis] = Math.ceil((ends[axis] - starts[axis]) / steps[axis]);\n  });\n  const outputTensorInfo: TensorInfo = { dims: outputShape, dataType: inputs[0].dataType };\n\n  const output = outputVariable('output', inputs[0].dataType, outputShape.length);\n  const input = inputVariable('input', inputs[0].dataType, inputs[0].dims.length);\n  const outputSize = ShapeUtil.size(outputShape);\n  const uniforms: UniformsArrayType = [\n    { name: 'outputSize', type: 'u32' },\n    { name: 'starts', type: 'u32', length: starts.length },\n    { name: 'signs', type: 'i32', length: signs.length },\n    { name: 'steps', type: 'u32', length: steps.length },\n  ];\n\n  const programUniforms: ProgramUniform[] = [\n    { type: DataType.uint32, data: outputSize },\n    { type: DataType.uint32, data: starts },\n    { type: DataType.int32, data: signs },\n    { type: DataType.uint32, data: steps },\n    ...createTensorShapeVariables(inputs[0].dims, outputShape),\n  ];\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n      ${shaderHelper.registerUniforms(uniforms).declareVariables(input, output)}\n        ${calculateInputIndicesImpl(input, output, inputShape)}\n        ${shaderHelper.mainStart()}\n          ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.outputSize')}\n          let output_indices = ${output.offsetToIndices('global_idx')};\n          let input_indices = calculateInputIndices(output_indices);\n          ${output.setByOffset('global_idx', input.getByIndices('input_indices'))}\n      }`;\n  return {\n    name: 'Slice',\n    shaderCache: { hint: `${signs.length}_${starts.length}_${steps.length}`, inputDependencies: ['rank'] },\n    getShaderSource,\n    getRunData: () => ({\n      outputs: [outputTensorInfo],\n      dispatchGroup: { x: Math.ceil(inputSize / 64 /* workgroup size */) },\n      programUniforms,\n    }),\n  };\n};\n\nexport const slice = (context: ComputeContext, attributes: SliceAttributes): void => {\n  validateInputs(context.inputs, attributes);\n  const updatedAttributes = createSliceAttributesFromInputs(context.inputs, attributes);\n  context.compute(createSliceProgramInfo(context.inputs, updatedAttributes), { inputs: [0] });\n  // if (ShapeUtil.size(program.outputs[0].dims) > 0) {\n  //   context.compute(programInfoLoader, {inputs: [0]});\n  // } else {\n  //   // TODO: support empty output\n  //   throw new Error('slice: output size is 0');\n  // }\n};\n\nexport const parseSliceAttributes = (attributes: Record<string, unknown>): SliceAttributes => {\n  const starts = attributes.starts as number[];\n  const ends = attributes.ends as number[];\n  const axes = attributes.axes as number[];\n  return createAttributeWithCacheKey({ starts, ends, axes });\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// TODO: this is the same naive implementation we use for reduce that has\n// performance limitations when the reduced axis is long. Need to add\n// a optimized codepath for this.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { AttributeWithCacheKey, createAttributeWithCacheKey } from '../attribute-with-cache-key';\nimport { ComputeContext } from '../types';\nimport { createTransposeProgramInfo } from './transpose';\n\nimport {\n  getMaxComponents,\n  inputVariable,\n  outputVariable,\n  ShaderHelper,\n  sumVector,\n  tensorTypeToWsglStorageType,\n} from './common';\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 1) {\n    throw new Error('Softmax op requires 1 input.');\n  }\n};\n\nexport interface SoftmaxAttributes extends AttributeWithCacheKey {\n  readonly axis: number;\n}\n\nconst createSoftmaxProgramInfo = (context: ComputeContext, attributes: SoftmaxAttributes) => {\n  const input = context.inputs[0];\n  const inputShape = input.dims;\n  const outputSize = ShapeUtil.size(inputShape);\n  const inputRank = inputShape.length;\n  const axis = ShapeUtil.normalizeAxis(attributes.axis, inputRank);\n  const isTransposeRequired = axis < inputShape.length - 1;\n  let transposedInput: TensorView;\n  let perm: number[] = [];\n\n  if (isTransposeRequired) {\n    perm = Array.from({ length: inputRank }, (_, i) => i);\n    perm[axis] = inputRank - 1;\n    perm[inputRank - 1] = axis;\n\n    transposedInput = context.compute(createTransposeProgramInfo(input, perm), {\n      inputs: [input],\n      outputs: [-1],\n    })[0];\n  } else {\n    transposedInput = input;\n  }\n\n  const transposedInputShape = transposedInput.dims;\n  const cols = transposedInputShape[inputRank - 1];\n  const rows = outputSize / cols;\n  const components = getMaxComponents(cols);\n  const packedCols = cols / components;\n  let WG = 64;\n  // If only one workgroup is dispatched, increase workgroupSize to improve parallelism.\n  if (rows === 1) {\n    WG = 256;\n  }\n  const maxVector = (name: string, components: number) => {\n    if (components === 4) {\n      return `max(max(${name}.x, ${name}.y), max(${name}.z, ${name}.w))`;\n    } else if (components === 2) {\n      return `max(${name}.x, ${name}.y)`;\n    } else if (components === 3) {\n      return `max(max(${name}.x, ${name}.y), ${name}.z)`;\n    }\n\n    return name;\n  };\n  const x = inputVariable('x', transposedInput.dataType, transposedInput.dims, components);\n  const output = outputVariable('result', transposedInput.dataType, transposedInput.dims, components);\n  const valueType = x.type.value;\n  // 6.2.4 in wgsl spec\n  const threadMaxDecl =\n    tensorTypeToWsglStorageType(transposedInput.dataType) === 'f32'\n      ? `var threadMax = ${valueType}(-3.4028234663852886e+38f);`\n      : `var threadMax = ${valueType}(-65504.0h);`;\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n      var<workgroup> rowMaxShared : ${valueType};\n      var<workgroup> rowSumShared : ${valueType};\n      var<workgroup> threadShared : array<${valueType}, ${WG}>;\n\n      fn getValue(row: i32, col: i32, row_stride: i32) -> ${valueType} {\n        let index = row * row_stride + col;\n        return x[index];\n      }\n\n      fn setValue(row: i32, col: i32, row_stride: i32, value: ${valueType}) {\n        let index = row * row_stride + col;\n        result[index] = value;\n      }\n      ${shaderHelper.registerUniform('packedCols', 'i32').declareVariables(x, output)}\n      ${shaderHelper.mainStart(WG)}\n        let gindex = i32(global_idx);\n        let lindex = i32(local_idx);\n        const wg = ${WG};\n        let row = gindex / wg;\n        let cols = uniforms.packedCols;\n        let row_stride : i32 = uniforms.packedCols;\n\n        // find the rows max\n        ${threadMaxDecl}\n        for (var col = lindex; col < cols; col += wg) {\n          let value = getValue(row, col, row_stride);\n          threadMax = max(threadMax, value);\n        }\n        if (lindex < cols) {\n          threadShared[lindex] = threadMax;\n        }\n        workgroupBarrier();\n\n        var reduceSize = min(cols, wg);\n        for (var currSize = reduceSize >> 1;  currSize > 0; currSize = reduceSize >> 1) {\n          reduceSize = currSize + (reduceSize & 1);\n          if (lindex < currSize) {\n            threadShared[lindex] = max(threadShared[lindex], threadShared[lindex + reduceSize]);\n          }\n          workgroupBarrier();\n        }\n        if (lindex == 0) {\n          rowMaxShared = ${valueType}(${maxVector('threadShared[0]', components)});\n        }\n        workgroupBarrier();\n\n        // find the rows sum\n        var threadSum = ${valueType}(0.0);\n        for (var col = lindex; col < cols; col += wg) {\n          let subExp = exp(getValue(row, col, row_stride) - rowMaxShared);\n          threadSum += subExp;\n        }\n        threadShared[lindex] = threadSum;\n        workgroupBarrier();\n\n        for (var currSize = wg >> 1;  currSize > 0; currSize = currSize >> 1) {\n          if (lindex < currSize) {\n            threadShared[lindex] = threadShared[lindex] + threadShared[lindex + currSize];\n          }\n          workgroupBarrier();\n        }\n        if (lindex == 0) {\n          rowSumShared = ${valueType}(${sumVector('threadShared[0]', components)});\n        }\n        workgroupBarrier();\n\n        // calculate final value for each element in the row\n        for (var col = lindex; col < cols; col += wg) {\n          var value = exp(getValue(row, col, row_stride) - rowMaxShared) / rowSumShared;\n          // max operation protects against NaN since all values should be >=0\n          value = max(value, ${valueType}(0.0));\n          setValue(row, col, row_stride, value);\n        }\n      }`;\n  const result = context.compute(\n    {\n      name: 'Softmax',\n      // Note that in JSEP, WG size is not included in cache by default, but WebGPU EP it is.\n      shaderCache: { hint: `${components};${WG}`, inputDependencies: ['type'] },\n      getRunData: () => ({\n        outputs: [{ dims: transposedInputShape, dataType: transposedInput.dataType }],\n        dispatchGroup: { x: rows },\n        programUniforms: [{ type: DataType.int32, data: packedCols }],\n      }),\n      getShaderSource,\n    },\n    {\n      inputs: [transposedInput],\n      outputs: [isTransposeRequired ? -1 : 0],\n    },\n  )[0];\n\n  if (isTransposeRequired) {\n    context.compute(createTransposeProgramInfo(result, perm), {\n      inputs: [result],\n    });\n  }\n};\n\nexport const softmax = (context: ComputeContext, attributes: SoftmaxAttributes): void => {\n  validateInputs(context.inputs);\n  createSoftmaxProgramInfo(context, attributes);\n};\n\nexport const parseSoftmaxAttributes = (attributes: Record<string, unknown>): SoftmaxAttributes =>\n  createAttributeWithCacheKey({ axis: attributes.axis as number });\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { ShapeUtil } from '../../util';\nimport { ComputeContext, ProgramInfo } from '../types';\n\nimport { createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper } from './common';\n\nconst getRepeats = (repeatsTensorView: TensorView): readonly number[] =>\n  Array.from(repeatsTensorView.getBigInt64Array(), Number);\n\nconst validateInputs = (inputs: readonly TensorView[]): void => {\n  if (!inputs || inputs.length !== 2) {\n    throw new Error('Tile requires 2 inputs.');\n  }\n\n  if (\n    inputs[0].dataType !== DataType.float &&\n    inputs[0].dataType !== DataType.float16 &&\n    inputs[0].dataType !== DataType.int32 &&\n    inputs[0].dataType !== DataType.uint32\n  ) {\n    throw new Error('Tile only support float, float16, int32, and uint32 data types');\n  }\n\n  if (inputs[1].dataType !== DataType.int64) {\n    throw new Error('Tile `repeats` input should be of int64 data type');\n  }\n\n  if (inputs[1].dims.length !== 1) {\n    throw new Error('Tile `repeats` input should be 1-D');\n  }\n\n  const repeats: readonly number[] = getRepeats(inputs[1]);\n\n  if (repeats.length !== inputs[0].dims.length) {\n    throw new Error('Tile `repeats` input should have same number of elements as rank of input data tensor');\n  }\n};\n\nconst getOutputShape = (inputShape: readonly number[], repeats: readonly number[]): readonly number[] => {\n  const outputShape: number[] = [];\n\n  for (let i = 0; i < inputShape.length; ++i) {\n    outputShape.push(inputShape[i] * repeats[i]);\n  }\n\n  return outputShape;\n};\n\nexport const createTileProgramInfo = (inputs: readonly TensorView[], shape?: number[]): ProgramInfo => {\n  const inputShape = inputs[0].dims;\n  const repeats: readonly number[] = shape == null ? getRepeats(inputs[1]) : shape;\n  const outputShape = getOutputShape(inputShape, repeats);\n  const outputSize = ShapeUtil.size(outputShape);\n\n  const dataType = inputs[0].dataType;\n  const input = inputVariable('input', dataType, inputShape.length);\n  const output = outputVariable('output', dataType, outputShape.length);\n\n  const getShaderSource = (shaderHelper: ShaderHelper) => `\n      const inputShape = ${input.indices(...inputShape)};\n      ${shaderHelper.registerUniform('output_size', 'u32').declareVariables(input, output)}\n      ${shaderHelper.mainStart()}\n      ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.output_size')}\n      let output_indices = ${output.offsetToIndices('global_idx')};\n      var input_indices: ${input.type.indices};\n      for (var i = 0; i < ${inputShape.length}; i++) {\n        let input_dim_i = ${input.indicesGet('uniforms.input_shape', 'i')};\n        let input_dim_value = ${output.indicesGet('output_indices', 'i')}  % input_dim_i;\n\n        ${input.indicesSet('input_indices', 'i', 'input_dim_value')}\n      }\n      ${output.setByOffset('global_idx', input.getByIndices('input_indices'))}\n    }`;\n\n  return {\n    name: 'Tile',\n    shaderCache: { hint: `${repeats}`, inputDependencies: ['rank'] },\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: inputs[0].dataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */) },\n      programUniforms: [\n        { type: DataType.uint32, data: outputSize },\n        ...createTensorShapeVariables(inputs[0].dims, outputShape),\n      ],\n    }),\n    getShaderSource,\n  };\n};\n\nexport const tile = (context: ComputeContext): void => {\n  validateInputs(context.inputs);\n  context.compute(createTileProgramInfo(context.inputs), { inputs: [0] });\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { DataType } from '../../../wasm-common';\nimport { TensorView } from '../../tensor-view';\nimport { BroadcastUtil, ShapeUtil } from '../../util';\nimport { ComputeContext, ProgramInfo } from '../types';\n\nimport { createTensorShapeVariables, inputVariable, outputVariable, ShaderHelper } from './common';\n\nconst createWhereOpProgramShader = (\n  shaderHelper: ShaderHelper,\n  inputs: readonly TensorView[],\n  dimsOutput: readonly number[],\n  isBroadcast: boolean,\n  typeOutput: number,\n) => {\n  const output = outputVariable('output_data', typeOutput, dimsOutput.length, 4);\n  const a = inputVariable('a_data', inputs[1].dataType, inputs[1].dims.length, 4);\n  const b = inputVariable('b_data', inputs[2].dataType, inputs[2].dims.length, 4);\n  const c = inputVariable('c_data', inputs[0].dataType, inputs[0].dims.length, 4);\n\n  let assignment: string;\n  const expression = (a: string, b: string, c: string) => `select(${b}, ${a}, ${c})`;\n  if (!isBroadcast) {\n    assignment = output.setByOffset(\n      'global_idx',\n      expression(a.getByOffset('global_idx'), b.getByOffset('global_idx'), c.getByOffset('global_idx')),\n    );\n  } else {\n    const singleAssignment = (resStr: string, x: number, typeCast = '') => {\n      const expressionA = `a_data[index_a${x}][component_a${x}]`;\n      const expressionB = `b_data[index_b${x}][component_b${x}]`;\n      const expressionC = `bool(c_data[index_c${x}] & (0xffu << (component_c${x} * 8)))`;\n      return `\n            let output_indices${x} = ${output.offsetToIndices(`global_idx * 4u + ${x}u`)};\n            let offset_a${x} = ${a.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let offset_b${x} = ${b.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let offset_c${x} = ${c.broadcastedIndicesToOffset(`output_indices${x}`, output)};\n            let index_a${x} = offset_a${x} / 4u;\n            let index_b${x} = offset_b${x} / 4u;\n            let index_c${x} = offset_c${x} / 4u;\n            let component_a${x} = offset_a${x} % 4u;\n            let component_b${x} = offset_b${x} % 4u;\n            let component_c${x} = offset_c${x} % 4u;\n            ${resStr}[${x}] = ${typeCast}(${expression(expressionA, expressionB, expressionC)});\n          `;\n    };\n    if (typeOutput === DataType.bool) {\n      assignment = `\n            var data = vec4<u32>(0);\n            ${singleAssignment('data', 0, 'u32')}\n            ${singleAssignment('data', 1, 'u32')}\n            ${singleAssignment('data', 2, 'u32')}\n            ${singleAssignment('data', 3, 'u32')}\n            output_data[global_idx] = dot(vec4<u32>(0x1, 0x100, 0x10000, 0x1000000), vec4<u32>(data));`;\n    } else {\n      assignment = `\n            ${singleAssignment('output_data[global_idx]', 0)}\n            ${singleAssignment('output_data[global_idx]', 1)}\n            ${singleAssignment('output_data[global_idx]', 2)}\n            ${singleAssignment('output_data[global_idx]', 3)}\n          `;\n    }\n  }\n\n  return `\n        ${shaderHelper.registerUniform('vec_size', 'u32').declareVariables(c, a, b, output)}\n        ${shaderHelper.mainStart()}\n        ${shaderHelper.guardAgainstOutOfBoundsWorkgroupSizes('uniforms.vec_size')}\n        ${assignment}\n      }`;\n};\n\nconst createWhereOpProgramInfo = (inputs: readonly TensorView[]): ProgramInfo => {\n  const dimsA = inputs[1].dims;\n  const dimsB = inputs[2].dims;\n  const dimsC = inputs[0].dims;\n  const outputDataType = inputs[1].dataType;\n\n  const isBroadcast = !(ShapeUtil.areEqual(dimsA, dimsB) && ShapeUtil.areEqual(dimsB, dimsC));\n  let outputShape = dimsA;\n  let outputSize = ShapeUtil.size(dimsA);\n  // TODO: deal with zero-sized tensors (eg. dims=[1,0])\n\n  if (isBroadcast) {\n    const calculatedShape = BroadcastUtil.calcShape(BroadcastUtil.calcShape(dimsA, dimsB, false)!, dimsC, false);\n    if (!calculatedShape) {\n      throw new Error(\"Can't perform where op on the given tensors\");\n    }\n    outputShape = calculatedShape;\n    outputSize = ShapeUtil.size(outputShape);\n  }\n\n  const vecSize = Math.ceil(outputSize / 4);\n\n  return {\n    name: 'Where',\n    shaderCache: { inputDependencies: ['rank', 'rank', 'rank'] },\n    getShaderSource: (shaderHelper) =>\n      createWhereOpProgramShader(shaderHelper, inputs, outputShape, isBroadcast, outputDataType),\n    getRunData: () => ({\n      outputs: [{ dims: outputShape, dataType: outputDataType }],\n      dispatchGroup: { x: Math.ceil(outputSize / 64 /* workgroup size */ / 4 /* vec size */) },\n      programUniforms: [\n        { type: DataType.uint32, data: vecSize },\n        ...createTensorShapeVariables(dimsC, dimsA, dimsB, outputShape),\n      ],\n    }),\n  };\n};\n\nexport const where = (context: ComputeContext): void => {\n  context.compute(createWhereOpProgramInfo(context.inputs));\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { argMax, argMin, parseArgMinMaxAttributes } from './ops/argminmax';\nimport { attention } from './ops/attention';\nimport { batchNorm } from './ops/batch-norm';\nimport { biasAdd } from './ops/bias-add';\nimport { biasSplitGelu } from './ops/bias-split-gelu';\nimport * as binaryOps from './ops/binary-op';\nimport { concat, parseConcatAttributes } from './ops/concat';\nimport { conv, parseConvAttributes } from './ops/conv';\nimport { convTranspose, parseConvTransposeAttributes } from './ops/conv-transpose';\nimport { cumsum, parseCumSumAttributes } from './ops/cumsum';\nimport { depthToSpace, parseDepthToSpaceAttributes } from './ops/depth-to-space';\nimport { einsum, parseEinsumAttributes } from './ops/einsum';\nimport { expand } from './ops/expand';\nimport { fastGelu } from './ops/fast-gelu';\nimport { gather, parseGatherAttributes } from './ops/gather';\nimport { gatherND, parseGatherNDAttributes } from './ops/gather-nd';\nimport { gatherBlockQuantized, parseGatherBlockQuantizedAttributes } from './ops/gather-block-quantized';\nimport { gatherElements, parseGatherElementsAttributes } from './ops/gather-elements';\nimport { gemm, parseGemmAttributes } from './ops/gemm';\nimport { gridSample, parseGridSampleAttributes } from './ops/grid-sample';\nimport { groupQueryAttention } from './ops/group-query-attention';\nimport { instanceNorm } from './ops/instance-norm';\nimport { layerNorm } from './ops/layer-norm';\nimport { matMul } from './ops/matmul';\nimport { matMulNBits, parseMatMulNBitsAttributes } from './ops/matmulnbits';\nimport { multiHeadAttention, parseMultiHeadAttentionAttributes } from './ops/multihead-attention';\nimport { pad } from './ops/pad';\nimport * as pool from './ops/pool';\nimport { dequantizeLinear, parseDequantizeLinearAttributes } from './ops/quantize-linear';\nimport { range } from './ops/range';\nimport { scatterND, parseScatterNDAttributes } from './ops/scatter-nd';\nimport {\n  reduceL1,\n  reduceL2,\n  reduceLogSum,\n  reduceLogSumExp,\n  reduceMax,\n  reduceMean,\n  reduceMin,\n  reduceProd,\n  reduceSum,\n  reduceSumSquare,\n} from './ops/reduce';\nimport { parseResizeAttributes, resize } from './ops/resize';\nimport { rotaryEmbedding } from './ops/rotary-embedding';\nimport { skipLayerNorm } from './ops/skip-layer-norm';\nimport { parseSliceAttributes, slice } from './ops/slice';\nimport { parseSoftmaxAttributes, softmax } from './ops/softmax';\nimport { parseSplitAttributes, split } from './ops/split';\nimport { tile } from './ops/tile';\nimport { parseTransposeAttributes, transpose } from './ops/transpose';\nimport * as unaryOps from './ops/unary-op';\nimport { where } from './ops/where';\nimport { ComputeContext } from './types';\n\nexport type RunFunction = (context: ComputeContext, attribute?: unknown) => void;\nexport type ParseAttributeFunction = (attributeRaw: unknown) => unknown;\nexport type OperatorImplementation = [RunFunction] | [RunFunction, ParseAttributeFunction];\n\nexport const WEBGPU_OP_RESOLVE_RULES: Map<string, OperatorImplementation> = new Map([\n  ['Abs', [unaryOps.abs]],\n  ['Acos', [unaryOps.acos]],\n  ['Acosh', [unaryOps.acosh]],\n  ['Add', [binaryOps.add]],\n  ['ArgMax', [argMax, parseArgMinMaxAttributes]],\n  ['ArgMin', [argMin, parseArgMinMaxAttributes]],\n  ['Asin', [unaryOps.asin]],\n  ['Asinh', [unaryOps.asinh]],\n  ['Atan', [unaryOps.atan]],\n  ['Atanh', [unaryOps.atanh]],\n  ['Attention', [attention]],\n  // TODO: support new attributes for AveragePool-10\n  ['AveragePool', [pool.averagePool, pool.parseAveragePoolAttributes]],\n  ['BatchNormalization', [batchNorm]],\n  ['BiasAdd', [biasAdd]],\n  ['BiasSplitGelu', [biasSplitGelu]],\n  ['Cast', [unaryOps.cast, unaryOps.parseCastAttributes]],\n  ['Ceil', [unaryOps.ceil]],\n  ['Clip', [unaryOps.clip]],\n  ['Concat', [concat, parseConcatAttributes]],\n  ['Conv', [conv, parseConvAttributes]],\n  ['ConvTranspose', [convTranspose, parseConvTransposeAttributes]],\n  ['Cos', [unaryOps.cos]],\n  ['Cosh', [unaryOps.cosh]],\n  ['CumSum', [cumsum, parseCumSumAttributes]],\n  ['DepthToSpace', [depthToSpace, parseDepthToSpaceAttributes]],\n  ['DequantizeLinear', [dequantizeLinear, parseDequantizeLinearAttributes]],\n  ['Div', [binaryOps.div]],\n  ['Einsum', [einsum, parseEinsumAttributes]],\n  ['Elu', [unaryOps.elu, unaryOps.parseAlphaAttributes]],\n  ['Equal', [binaryOps.equal]],\n  ['Erf', [unaryOps.erf]],\n  ['Exp', [unaryOps.exp]],\n  ['Expand', [expand]],\n  ['FastGelu', [fastGelu]],\n  ['Floor', [unaryOps.floor]],\n  ['FusedConv', [conv, parseConvAttributes]],\n  ['Gather', [gather, parseGatherAttributes]],\n  ['GatherElements', [gatherElements, parseGatherElementsAttributes]],\n  ['GatherBlockQuantized', [gatherBlockQuantized, parseGatherBlockQuantizedAttributes]],\n  ['GatherND', [gatherND, parseGatherNDAttributes]],\n  ['Gelu', [unaryOps.gelu]],\n  ['Gemm', [gemm, parseGemmAttributes]],\n  ['GlobalAveragePool', [pool.globalAveragePool, pool.parseGlobalAveragePoolAttributes]],\n  ['GlobalMaxPool', [pool.globalMaxPool, pool.parseGlobalMaxPoolAttributes]],\n  ['Greater', [binaryOps.greater]],\n  ['GreaterOrEqual', [binaryOps.greaterOrEqual]],\n  ['GridSample', [gridSample, parseGridSampleAttributes]],\n  ['GroupQueryAttention', [groupQueryAttention]],\n  ['HardSigmoid', [unaryOps.hardSigmoid, unaryOps.parseHardSigmoidAttributes]],\n  ['InstanceNormalization', [instanceNorm]],\n  ['LayerNormalization', [layerNorm]],\n  ['LeakyRelu', [unaryOps.leakyRelu, unaryOps.parseAlphaAttributes]],\n  ['Less', [binaryOps.less]],\n  ['LessOrEqual', [binaryOps.lessOrEqual]],\n  ['Log', [unaryOps.log]],\n  ['MatMul', [matMul]],\n  ['MatMulNBits', [matMulNBits, parseMatMulNBitsAttributes]],\n  // TODO: support new attributes for MaxPool-8 and MaxPool-10\n  ['MaxPool', [pool.maxPool, pool.parseMaxPoolAttributes]],\n  ['Mul', [binaryOps.mul]],\n  ['MultiHeadAttention', [multiHeadAttention, parseMultiHeadAttentionAttributes]],\n  ['Neg', [unaryOps.neg]],\n  ['Not', [unaryOps.not]],\n  ['Pad', [pad]],\n  ['Pow', [binaryOps.pow]],\n  ['QuickGelu', [unaryOps.quickgelu, unaryOps.parseAlphaAttributes]],\n  ['Range', [range]],\n  ['Reciprocal', [unaryOps.reciprocal]],\n  ['ReduceMin', [reduceMin]],\n  ['ReduceMean', [reduceMean]],\n  ['ReduceMax', [reduceMax]],\n  ['ReduceSum', [reduceSum]],\n  ['ReduceProd', [reduceProd]],\n  ['ReduceL1', [reduceL1]],\n  ['ReduceL2', [reduceL2]],\n  ['ReduceLogSum', [reduceLogSum]],\n  ['ReduceLogSumExp', [reduceLogSumExp]],\n  ['ReduceSumSquare', [reduceSumSquare]],\n  ['Relu', [unaryOps.relu]],\n  ['Resize', [resize, parseResizeAttributes]],\n  ['RotaryEmbedding', [rotaryEmbedding]],\n  ['ScatterND', [scatterND, parseScatterNDAttributes]],\n  ['Sigmoid', [unaryOps.sigmoid]],\n  ['Sin', [unaryOps.sin]],\n  ['Sinh', [unaryOps.sinh]],\n  ['Slice', [slice, parseSliceAttributes]],\n  ['SkipLayerNormalization', [skipLayerNorm]],\n  ['Split', [split, parseSplitAttributes]],\n  ['Sqrt', [unaryOps.sqrt]],\n  ['Softmax', [softmax, parseSoftmaxAttributes]],\n  ['Sub', [binaryOps.sub]],\n  ['Tan', [unaryOps.tan]],\n  ['Tanh', [unaryOps.tanh]],\n  ['ThresholdedRelu', [unaryOps.thresholdedRelu, unaryOps.parseAlphaAttributes]],\n  ['Tile', [tile]],\n  ['Transpose', [transpose, parseTransposeAttributes]],\n  ['Where', [where]],\n]);\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { TRACE_FUNC_BEGIN, TRACE_FUNC_END } from 'onnxruntime-common';\n\nimport { WebGpuBackend } from '../backend-webgpu';\nimport { LOG_DEBUG } from '../log';\n\nimport { createShaderHelper } from './ops/common';\nimport { Artifact, GpuData, ProgramInfo } from './types';\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  attributesBound: boolean;\n\n  constructor(private backend: WebGpuBackend) {\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(\n    buildArtifact: Artifact,\n    inputs: GpuData[],\n    outputs: GpuData[],\n    dispatchGroup: [number, number, number],\n    uniformBufferBinding: GPUBindingResource | undefined,\n  ): void {\n    TRACE_FUNC_BEGIN(buildArtifact.programInfo.name);\n    const device = this.backend.device;\n    const computePassEncoder = this.backend.getComputePassEncoder();\n    this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2);\n    const entries = [];\n    for (const input of inputs) {\n      entries.push({ binding: entries.length, resource: { buffer: input.buffer } });\n    }\n    for (const output of outputs) {\n      entries.push({ binding: entries.length, resource: { buffer: output.buffer } });\n    }\n    if (uniformBufferBinding) {\n      entries.push({ binding: entries.length, resource: uniformBufferBinding });\n    }\n    const bindGroup = device.createBindGroup({\n      layout: buildArtifact.computePipeline.getBindGroupLayout(0),\n      entries,\n      label: buildArtifact.programInfo.name,\n    });\n\n    if (this.backend.sessionStatus === 'capturing') {\n      const commandInfo = {\n        kernelId: this.backend.currentKernelId!,\n        computePipeline: buildArtifact.computePipeline,\n        bindGroup,\n        dispatchGroup,\n      };\n      const sessionCommandList = this.backend.capturedCommandList.get(this.backend.currentSessionId!);\n      sessionCommandList!.push(commandInfo);\n    }\n\n    computePassEncoder.setPipeline(buildArtifact.computePipeline);\n    computePassEncoder.setBindGroup(0, bindGroup);\n    computePassEncoder.dispatchWorkgroups(...dispatchGroup);\n    this.backend.writeTimestamp(this.backend.pendingDispatchNumber * 2 + 1);\n    this.backend.pendingDispatchNumber++;\n\n    if (\n      this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber ||\n      this.backend.queryType === 'at-passes'\n    ) {\n      this.backend.endComputePass();\n    }\n    if (this.backend.pendingDispatchNumber >= this.backend.maxDispatchNumber) {\n      this.backend.flush();\n    }\n    TRACE_FUNC_END(buildArtifact.programInfo.name);\n  }\n  dispose(): void {\n    // this.repo.forEach(a => this.glContext.deleteProgram(a.program));\n  }\n  build(programInfo: ProgramInfo, normalizedDispatchGroupSize: [number, number, number]): Artifact {\n    TRACE_FUNC_BEGIN(programInfo.name);\n    const device = this.backend.device;\n    const enableDirectives: string[] = [];\n\n    // Enable WGSL extensions based on available WebGPU features\n    const extensionsInfo: Array<{ feature: GPUFeatureName; extension: string }> = [\n      { feature: 'shader-f16', extension: 'f16' },\n      { feature: 'subgroups' as GPUFeatureName, extension: 'subgroups' },\n    ];\n    extensionsInfo.forEach((info) => {\n      if (device.features.has(info.feature)) {\n        enableDirectives.push(`enable ${info.extension};`);\n      }\n    });\n\n    const shaderHelper = createShaderHelper(normalizedDispatchGroupSize, this.backend.device.limits);\n    const userCode = programInfo.getShaderSource(shaderHelper);\n    const code = `${enableDirectives.join('\\n')}\\n${shaderHelper.additionalImplementations}\\n${userCode}`;\n    const shaderModule = device.createShaderModule({ code, label: programInfo.name });\n    LOG_DEBUG('verbose', () => `[WebGPU] ${programInfo.name} shader code: ${code}`);\n\n    const computePipeline = device.createComputePipeline({\n      compute: { module: shaderModule, entryPoint: 'main' },\n      layout: 'auto',\n      label: programInfo.name,\n    });\n\n    TRACE_FUNC_END(programInfo.name);\n    return { programInfo, computePipeline, uniformVariablesInfo: shaderHelper.variablesInfo };\n  }\n\n  normalizeDispatchGroupSize(\n    dispatchGroup: ReturnType<ProgramInfo['getRunData']>['dispatchGroup'],\n  ): [number, number, number] {\n    const x = typeof dispatchGroup === 'number' ? dispatchGroup : dispatchGroup.x;\n    const y = typeof dispatchGroup === 'number' ? 1 : dispatchGroup.y || 1;\n    const z = typeof dispatchGroup === 'number' ? 1 : dispatchGroup.z || 1;\n    const limitPerDimension = this.backend.device.limits.maxComputeWorkgroupsPerDimension;\n    if (x <= limitPerDimension && y <= limitPerDimension && z <= limitPerDimension) {\n      return [x, y, z];\n    }\n    const size = x * y * z;\n    let dispatchAverage = Math.ceil(Math.sqrt(size));\n    if (dispatchAverage > limitPerDimension) {\n      dispatchAverage = Math.ceil(Math.cbrt(size));\n      if (dispatchAverage > limitPerDimension) {\n        throw new Error('Total dispatch size exceeds WebGPU maximum.');\n      }\n      return [dispatchAverage, dispatchAverage, dispatchAverage];\n    } else {\n      return [dispatchAverage, dispatchAverage, 1];\n    }\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Env, Tensor, TRACE, TRACE_FUNC_BEGIN, TRACE_FUNC_END } from 'onnxruntime-common';\n\nimport { DataType, tensorDataTypeEnumToString } from '../wasm-common';\n\nimport { configureLogger, LOG_DEBUG } from './log';\nimport { createView, TensorView } from './tensor-view';\nimport { createGpuDataManager, downloadGpuData, GpuDataManager } from './webgpu/gpu-data-manager';\nimport { RunFunction, WEBGPU_OP_RESOLVE_RULES } from './webgpu/op-resolve-rules';\nimport { ProgramManager } from './webgpu/program-manager';\nimport {\n  AdapterInfo,\n  ComputeContext,\n  GpuArchitecture,\n  GpuData,\n  GpuVendor,\n  ProgramInfo,\n  ProgramInputTensorInfoDependency,\n  SessionState,\n  TimestampQuery,\n} from './webgpu/types';\n\ninterface CommandInfo {\n  readonly kernelId: number;\n  readonly computePipeline: GPUComputePipeline;\n  readonly bindGroup: GPUBindGroup;\n  readonly dispatchGroup: [number, number, number];\n}\n\ninterface KernelInfo {\n  readonly kernelType: string;\n  readonly kernelName: string;\n  readonly kernelEntry: RunFunction;\n  readonly attributes: [((attribute: unknown) => unknown) | undefined, unknown];\n}\n\ninterface PendingKernelInfo {\n  readonly kernelId: number;\n  readonly programName: string;\n  readonly inputTensorViews: readonly TensorView[];\n  readonly outputTensorViews: readonly TensorView[];\n}\n\nconst getProgramInputTensorInfoDependencyKey = (\n  inputTensors: readonly TensorView[],\n  inputDependencies: readonly ProgramInputTensorInfoDependency[],\n): string => {\n  if (inputDependencies.length !== inputTensors.length) {\n    throw new Error(\n      `inputDependencies length ${inputDependencies.length} is not equal to inputTensors length ${\n        inputTensors.length\n      }.`,\n    );\n  }\n\n  const inputInfos: string[] = [];\n  for (let i = 0; i < inputTensors.length; ++i) {\n    const type = inputTensors[i].dataType;\n    switch (inputDependencies[i]) {\n      case 'none': {\n        inputInfos.push('');\n        break;\n      }\n      case 'type': {\n        inputInfos.push(`${type}`);\n        break;\n      }\n      case 'rank': {\n        const rank = inputTensors[i].dims.length;\n        inputInfos.push(`${type};${rank}`);\n        break;\n      }\n      case 'dims': {\n        const dims = inputTensors[i].dims.join(',');\n        inputInfos.push(`${type};${dims}`);\n        break;\n      }\n      default:\n        throw new Error(`unsupported input dependency: ${inputDependencies[i]}`);\n    }\n  }\n\n  return inputInfos.join('|');\n};\n\n/**\n * get a unique key representing the program from the program info, input shapes and types.\n *\n * @returns a unique key is a shorter string than the shader source, which contains all the information to identify a\n * program. if the key is the same, the program shader source should be the same, so we can reuse the program.\n *\n */\nconst getProgramInfoUniqueKey = (\n  programInfo: ProgramInfo,\n  inputTensors: readonly TensorView[],\n  is1DimensionDispatch: boolean,\n): string => {\n  // final key format:\n  // <PROGRAM_NAME>[<PROGRAM_CUSTOM_CACHE_HINT>]:is1DimensionDispatch:<INPUTS_INFO_0>|<INPUTS_INFO_1>|...\n  let key = programInfo.name;\n  if (programInfo.shaderCache?.hint) {\n    key += '[' + programInfo.shaderCache.hint + ']';\n  }\n  key +=\n    ':' +\n    is1DimensionDispatch +\n    `:${getProgramInputTensorInfoDependencyKey(\n      inputTensors,\n      programInfo.shaderCache?.inputDependencies ??\n        new Array<ProgramInputTensorInfoDependency>(inputTensors.length).fill('dims'),\n    )}`;\n  return key;\n};\n\nclass AdapterInfoImpl implements AdapterInfo {\n  readonly architecture?: string;\n  readonly vendor?: string;\n\n  constructor(adapterInfo: GPUAdapterInfo) {\n    if (adapterInfo) {\n      this.architecture = adapterInfo.architecture;\n      this.vendor = adapterInfo.vendor;\n    }\n  }\n\n  isArchitecture(architecture: GpuArchitecture): boolean {\n    return this.architecture === architecture;\n  }\n\n  isVendor(vendor: GpuVendor): boolean {\n    return this.vendor === vendor;\n  }\n}\n\n/**\n * this class is designed to store status and being used as a singleton for JSEP. It will be passed to jsepInit() as\n * the first parameter so that it is stored for future use.\n */\nexport class WebGpuBackend {\n  adapterInfo: AdapterInfoImpl;\n  device: GPUDevice;\n  /**\n   * an instance of GpuDataManager to manage a GpuDataId -> GpuBuffer mapping\n   */\n  gpuDataManager: GpuDataManager;\n  /**\n   * an instance of ProgramManager to build and run WebGPU compute shader program, and manage a ProgramKey -> Program\n   * artifacts mapping\n   */\n  programManager: ProgramManager;\n\n  /**\n   * representing the session ID of which is currently being run.\n   * `null` means no session is being run.\n   * only valid when session.run is executed.\n   */\n  currentSessionId: number | null = null;\n\n  /**\n   * representing the kernel ID of which is currently being computed (CPU code perspective).\n   * `null` means no kernel is being computed.\n   * only one kernel can be computed at a moment.\n   */\n  currentKernelId: number | null = null;\n  /**\n   * a list of temporary GPU data for the current kernel. should release when the kernel done computation.\n   */\n  private temporaryData: GpuData[];\n  /**\n   * a KernelID -> a GPU data list, which stores persistent GPU data owned by the specific kernel.\n   */\n  private kernelPersistentData: Map<number, GpuData[]>;\n  /**\n   * a KernelID -> a custom data, which stores custom data owned by the specific kernel.\n   */\n  private kernelCustomData: Map<number, { [key: string]: unknown }>;\n  /**\n   * get the custom data of the current kernel\n   */\n  get currentKernelCustomData(): { [key: string]: unknown } {\n    if (this.currentKernelId === null) {\n      throw new Error('currentKernelCustomData(): currentKernelId is null. (should not happen)');\n    }\n\n    let data = this.kernelCustomData.get(this.currentKernelId);\n    if (!data) {\n      data = {};\n      this.kernelCustomData.set(this.currentKernelId, data);\n    }\n\n    return data;\n  }\n\n  // KernelID -> kernelInfo mapping\n  kernels: Map<number, KernelInfo>;\n  private commandEncoder: GPUCommandEncoder | null = null;\n  private computePassEncoder: GPUComputePassEncoder | null = null;\n  maxDispatchNumber = 16;\n  pendingDispatchNumber = 0;\n\n  // info of kernels pending submission for a single batch\n  private pendingKernels: PendingKernelInfo[] = [];\n  // queryReadBuffer -> pendingKernels mapping for all the batches\n  private pendingQueries: Map<GPUBuffer, PendingKernelInfo[]> = new Map();\n  private queryResolveBuffer?: GPUBuffer;\n  private querySet?: GPUQuerySet;\n  private queryTimeBase?: bigint;\n  queryType: TimestampQuery;\n\n  env: Env;\n  sessionStatus: SessionState = 'default';\n  /**\n   * a SessionID -> CommandInfo[] mapping. It's used to record all GPU commands for corresponding session.\n   */\n  capturedCommandList: Map<number, CommandInfo[]> = new Map();\n\n  /**\n   * a SessionID -> PendingKernelInfo[] mapping for profiling.\n   */\n  private capturedPendingKernels: Map<number, PendingKernelInfo[]> = new Map();\n\n  /**\n   * a SessionID -> a Map of (InputOutputIndex -> [ID, GPUBuffer]) mapping.\n   */\n  sessionExternalDataMapping: Map<number, Map<number, [number, GPUBuffer]>> = new Map();\n\n  async initialize(env: Env, adapter: GPUAdapter): Promise<void> {\n    this.env = env;\n    const requiredFeatures: GPUFeatureName[] = [];\n    const deviceDescriptor: GPUDeviceDescriptor = {\n      requiredLimits: {\n        maxComputeWorkgroupStorageSize: adapter.limits.maxComputeWorkgroupStorageSize,\n        maxComputeWorkgroupsPerDimension: adapter.limits.maxComputeWorkgroupsPerDimension,\n        maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,\n        maxBufferSize: adapter.limits.maxBufferSize,\n        maxComputeInvocationsPerWorkgroup: adapter.limits.maxComputeInvocationsPerWorkgroup,\n        maxComputeWorkgroupSizeX: adapter.limits.maxComputeWorkgroupSizeX,\n        maxComputeWorkgroupSizeY: adapter.limits.maxComputeWorkgroupSizeY,\n        maxComputeWorkgroupSizeZ: adapter.limits.maxComputeWorkgroupSizeZ,\n      },\n      requiredFeatures,\n    };\n\n    // Try requiring WebGPU features\n    const requireFeatureIfAvailable = (feature: GPUFeatureName) =>\n      adapter.features.has(feature) && requiredFeatures.push(feature) && true;\n    // Try chromium-experimental-timestamp-query-inside-passes and fallback to timestamp-query\n    if (!requireFeatureIfAvailable('chromium-experimental-timestamp-query-inside-passes' as GPUFeatureName)) {\n      requireFeatureIfAvailable('timestamp-query');\n    }\n    requireFeatureIfAvailable('shader-f16');\n    // Try subgroups\n    requireFeatureIfAvailable('subgroups' as GPUFeatureName);\n\n    this.device = await adapter.requestDevice(deviceDescriptor);\n    this.adapterInfo = new AdapterInfoImpl(adapter.info || (await adapter.requestAdapterInfo()));\n    this.gpuDataManager = createGpuDataManager(this);\n    this.programManager = new ProgramManager(this);\n    this.kernels = new Map();\n    this.kernelPersistentData = new Map();\n    this.kernelCustomData = new Map();\n\n    // set up flags for logger\n    configureLogger(env.logLevel!, !!env.debug);\n\n    // TODO: set up flags\n\n    this.device.onuncapturederror = (ev) => {\n      if (ev.error instanceof GPUValidationError) {\n        // eslint-disable-next-line no-console\n        console.error(`An uncaught WebGPU validation error was raised: ${ev.error.message}`);\n      }\n    };\n\n    Object.defineProperty(this.env.webgpu, 'device', {\n      value: this.device,\n      writable: false,\n      enumerable: true,\n      configurable: true, // Allow deletion when device is destroyed\n    });\n    Object.defineProperty(this.env.webgpu, 'adapter', {\n      value: adapter,\n      writable: false,\n      enumerable: true,\n      configurable: false,\n    });\n\n    // init queryType, which is necessary for InferenceSession.create\n    this.setQueryType();\n  }\n\n  dispose(): void {\n    if (typeof this.querySet !== 'undefined') {\n      this.querySet.destroy();\n    }\n    this.gpuDataManager.dispose();\n\n    // Clear the device reference when it's lost to allow new sessions to create a fresh device\n    // This handles the case where preserve_device=false (default) causes the C++ side to destroy the device\n    if (this.device && this.env?.webgpu) {\n      void this.device.lost.then(() => {\n        delete (this.env.webgpu as unknown as Record<string, unknown>).device;\n      });\n    }\n  }\n\n  getCommandEncoder(): GPUCommandEncoder {\n    if (!this.commandEncoder) {\n      this.commandEncoder = this.device.createCommandEncoder();\n    }\n    return this.commandEncoder;\n  }\n\n  getComputePassEncoder(): GPUComputePassEncoder {\n    if (!this.computePassEncoder) {\n      const commandEncoder = this.getCommandEncoder();\n      const computePassDescriptor: GPUComputePassDescriptor = {};\n\n      if (this.queryType === 'at-passes') {\n        computePassDescriptor.timestampWrites = {\n          querySet: this.querySet!,\n          beginningOfPassWriteIndex: this.pendingDispatchNumber * 2,\n          endOfPassWriteIndex: this.pendingDispatchNumber * 2 + 1,\n        };\n      }\n\n      this.computePassEncoder = commandEncoder.beginComputePass(computePassDescriptor);\n    }\n    return this.computePassEncoder;\n  }\n\n  endComputePass(): void {\n    if (this.computePassEncoder) {\n      this.computePassEncoder.end();\n      this.computePassEncoder = null;\n    }\n  }\n\n  flush(): void {\n    if (!this.commandEncoder) {\n      return;\n    }\n\n    TRACE_FUNC_BEGIN();\n\n    this.endComputePass();\n    let queryReadBuffer: GPUBuffer;\n    if (this.queryType !== 'none') {\n      this.commandEncoder.resolveQuerySet(\n        this.querySet!,\n        0,\n        this.pendingDispatchNumber * 2,\n        this.queryResolveBuffer!,\n        0,\n      );\n\n      queryReadBuffer = this.device.createBuffer(\n        // eslint-disable-next-line no-bitwise\n        { size: this.pendingDispatchNumber * 2 * 8, usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST },\n      );\n\n      this.pendingQueries.set(queryReadBuffer, this.pendingKernels);\n      this.pendingKernels = [];\n      this.commandEncoder.copyBufferToBuffer(\n        this.queryResolveBuffer!,\n        0,\n        queryReadBuffer,\n        0,\n        this.pendingDispatchNumber * 2 * 8,\n      );\n    }\n\n    this.device.queue.submit([this.commandEncoder.finish()]);\n    this.gpuDataManager.refreshPendingBuffers();\n    this.commandEncoder = null;\n    this.pendingDispatchNumber = 0;\n\n    if (this.queryType !== 'none') {\n      void queryReadBuffer!.mapAsync(GPUMapMode.READ).then(() => {\n        const mappedData = new BigUint64Array(queryReadBuffer.getMappedRange());\n        const pendingKernels = this.pendingQueries.get(queryReadBuffer)!;\n        for (let i = 0; i < mappedData.length / 2; i++) {\n          const pendingKernelInfo = pendingKernels[i];\n          const kernelId = pendingKernelInfo.kernelId;\n          const kernelInfo = this.kernels.get(kernelId)!;\n          const kernelType = kernelInfo.kernelType;\n          const kernelName = kernelInfo.kernelName;\n          const programName = pendingKernelInfo.programName;\n          const inputTensorViews = pendingKernelInfo.inputTensorViews;\n          const outputTensorViews = pendingKernelInfo.outputTensorViews;\n          const startTimeU64 = mappedData[i * 2];\n          const endTimeU64 = mappedData[i * 2 + 1];\n\n          if (typeof this.queryTimeBase === 'undefined') {\n            this.queryTimeBase = startTimeU64;\n          }\n\n          const startTime = Number(startTimeU64 - this.queryTimeBase);\n          const endTime = Number(endTimeU64 - this.queryTimeBase);\n\n          if (!Number.isSafeInteger(startTime) || !Number.isSafeInteger(endTime)) {\n            throw new RangeError('incorrect timestamp range');\n          }\n\n          if (this.env.webgpu.profiling?.ondata) {\n            this.env.webgpu.profiling.ondata({\n              version: 1,\n              inputsMetadata: inputTensorViews.map((value) => ({\n                dims: value.dims,\n                dataType: tensorDataTypeEnumToString(value.dataType),\n              })),\n              outputsMetadata: outputTensorViews.map((value) => ({\n                dims: value.dims,\n                dataType: tensorDataTypeEnumToString(value.dataType),\n              })),\n              kernelId,\n              kernelType,\n              kernelName,\n              programName,\n              startTime,\n              endTime,\n            });\n          } else {\n            // if no callback is provided, print the profiling message to console\n            let inputShapes = '';\n            inputTensorViews.forEach((value, i) => {\n              inputShapes += `input[${i}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `;\n            });\n            let outputShapes = '';\n            outputTensorViews.forEach((value, i) => {\n              outputShapes += `output[${i}]: [${value.dims}] | ${tensorDataTypeEnumToString(value.dataType)}, `;\n            });\n            // eslint-disable-next-line no-console\n            console.log(\n              `[profiling] kernel \"${kernelId}|${kernelType}|${kernelName}|${programName}\" ${inputShapes}${\n                outputShapes\n              }start time: ${startTime} ns, execution time: ${endTime - startTime} ns`,\n            );\n          }\n          TRACE('GPU', `${programName}::${startTimeU64}::${endTimeU64}`);\n        }\n        queryReadBuffer.unmap();\n        this.pendingQueries.delete(queryReadBuffer);\n      });\n    }\n    TRACE_FUNC_END();\n  }\n\n  /**\n   * run a WebGPU program.\n   * @param program a ProgramInfo instance\n   * @param inputTensorViews a TensorView array. each element represents a value already exists in GPU.\n   * @param outputIndices an indices array. each element can be either -1 (temporary data), -2 (persistent data) or an\n   * index to the kernel's output.\n   * @param createKernelOutput a callback function that create a value to kernel's output with the given index\n   * @param createIntermediateOutput a callback function that create a value as a intermediate value, either temporary\n   * or persistent (owned by the current kernel)\n   * @returns a TensorView array representing the result.\n   */\n  run(\n    program: ProgramInfo,\n    inputTensorViews: readonly TensorView[],\n    outputIndices: readonly number[],\n    createKernelOutput: (index: number, dataType: number, dims: readonly number[]) => TensorView,\n    createIntermediateOutput: (dataType: number, dims: readonly number[]) => TensorView,\n    outputCount: number,\n  ): TensorView[] {\n    TRACE_FUNC_BEGIN(program.name);\n    // create info for inputs\n    const inputDatas: GpuData[] = [];\n    for (let i = 0; i < inputTensorViews.length; ++i) {\n      const data = inputTensorViews[i].data;\n      // if tensor view data is 0, it means the output is zero-sized tensor, and there is no GPU data for it.\n      if (data === 0) {\n        continue;\n      }\n      const gpuData = this.gpuDataManager.get(data);\n      if (!gpuData) {\n        throw new Error(`no GPU data for input: ${data}`);\n      }\n      inputDatas.push(gpuData);\n    }\n\n    const { outputs, dispatchGroup, programUniforms } = program.getRunData(inputTensorViews);\n\n    // check output indices\n    const validatedOutputIndices = outputIndices.length === 0 ? outputs.map((_, i) => i) : outputIndices;\n    if (validatedOutputIndices.length !== outputs.length) {\n      throw new Error(`Output size ${validatedOutputIndices.length} must be equal to ${outputs.length}.`);\n    }\n\n    // create info for outputs\n    const outputTensorViews: TensorView[] = [];\n    const outputDatas: GpuData[] = [];\n    for (let i = 0; i < outputs.length; ++i) {\n      // value -1 and -2 are used for creating temporary and persistent outputs.\n      // value -3 is used for placeholder output. So -3, -2, -1 and 0, 1, 2, ... are valid\n      // output indices. see type definition of ComputeContextInputsOutputsMapping for more details.\n      if (\n        !Number.isInteger(validatedOutputIndices[i]) ||\n        validatedOutputIndices[i] < -3 ||\n        validatedOutputIndices[i] >= outputCount\n      ) {\n        throw new Error(`Invalid output index: ${validatedOutputIndices[i]}`);\n      }\n      if (validatedOutputIndices[i] === -3) {\n        continue;\n      }\n      const isTemporary = validatedOutputIndices[i] === -1;\n      const isPersistent = validatedOutputIndices[i] === -2;\n      const tensorView =\n        isTemporary || isPersistent\n          ? createIntermediateOutput(outputs[i].dataType, outputs[i].dims)\n          : createKernelOutput(validatedOutputIndices[i], outputs[i].dataType, outputs[i].dims);\n      outputTensorViews.push(tensorView);\n      // if tensor view data is 0, it means the output is zero-sized tensor, and there is no GPU data for it.\n      if (tensorView.data === 0) {\n        continue;\n      }\n      const gpuData = this.gpuDataManager.get(tensorView.data);\n      if (!gpuData) {\n        throw new Error(`no GPU data for output: ${tensorView.data}`);\n      }\n      if (isTemporary) {\n        this.temporaryData.push(gpuData);\n      }\n      if (isPersistent) {\n        let persistentData = this.kernelPersistentData.get(this.currentKernelId!);\n        if (!persistentData) {\n          persistentData = [];\n          this.kernelPersistentData.set(this.currentKernelId!, persistentData);\n        }\n        persistentData.push(gpuData);\n      }\n      outputDatas.push(gpuData);\n    }\n\n    // when there are any zero-sized tensor in the inputs or outputs, we should report error unless all outputs are\n    // zero-sized tensors.\n    if (inputDatas.length !== inputTensorViews.length || outputDatas.length !== outputTensorViews.length) {\n      // if all outputs are zero-sized tensors, there is no need to run the program.\n      if (outputDatas.length === 0) {\n        TRACE_FUNC_END(program.name);\n        return outputTensorViews;\n      }\n      // if some outputs are zero-sized tensors, report an error.\n      //\n      // TODO: so far we don't see any use case that outputs include both zero-sized tensors and non-zero-sized tensors.\n      // If we see such use case, we need to make a change here to support it.\n      throw new Error(\n        `Program ${program.name} has zero-sized tensor(s) in inputs or outputs. This is not supported now.`,\n      );\n    }\n\n    // load uniforms\n    // TODO: add cache for uniform (is it necessary?)\n    //\n    let uniformBufferBinding: GPUBindingResource | undefined;\n    if (programUniforms) {\n      let currentOffset = 0;\n      const offsets: number[] = [];\n\n      programUniforms.forEach((v) => {\n        const data = typeof v.data === 'number' ? [v.data] : v.data;\n        if (data.length === 0) {\n          return;\n        }\n        // https://www.w3.org/TR/WGSL/#alignof\n        const sizeOfElement = v.type === DataType.float16 ? 2 : 4;\n        let sizeOfVecOrMat;\n        let baseAlignment;\n        if (v.type === DataType.float16) {\n          baseAlignment = data.length > 4 ? 16 : data.length > 2 ? 8 : data.length * sizeOfElement;\n          sizeOfVecOrMat = data.length > 4 ? 16 : sizeOfElement * data.length;\n        } else {\n          baseAlignment = data.length <= 2 ? data.length * sizeOfElement : 16;\n          sizeOfVecOrMat = 16;\n        }\n        currentOffset = Math.ceil(currentOffset / baseAlignment) * baseAlignment;\n        offsets.push(currentOffset);\n        // For non-float16 type, when data.length > 4, the uniform variable is of type array<vec4<i32|u32|f32>,N>, where\n        // N = Math.ceil(data.length / 4) and SizeOf(vec4<i32|u32|f32>) = 16. The total byte length is N *\n        // SizeOf(vec4<i32|u32|f32>). For float16 type, when data.length > 4, the uniform variable is of type\n        // array<mat2x4<f16>,N>, where N = Math.ceil(data.length / 8) and SizeOf(mat2x4<f16>) = 16. The total byte\n        // length is N * SizeOf(mat2x4<f16>).\n        const elementPerVecOrMat = v.type === DataType.float16 ? 8 : 4;\n        currentOffset +=\n          data.length > 4 ? Math.ceil(data.length / elementPerVecOrMat) * sizeOfVecOrMat : data.length * sizeOfElement;\n      });\n\n      // Meet alignment of struct here: https://www.w3.org/TR/WGSL/#alignment-and-size. For simplicity, set\n      // maxAlignmentOfField to 16 since the underlying buffer has been rounded up to 16.\n      const maxAlignmentOfField = 16;\n      currentOffset = Math.ceil(currentOffset / maxAlignmentOfField) * maxAlignmentOfField;\n      const arrayBuffer = new ArrayBuffer(currentOffset);\n      programUniforms.forEach((v, i) => {\n        const offset = offsets[i];\n        const data = typeof v.data === 'number' ? [v.data] : v.data;\n        if (v.type === DataType.int32) {\n          new Int32Array(arrayBuffer, offset, data.length).set(data);\n        } else if (v.type === DataType.uint32) {\n          new Uint32Array(arrayBuffer, offset, data.length).set(data);\n        } else if (v.type === DataType.float16) {\n          new Uint16Array(arrayBuffer, offset, data.length).set(data);\n        } else if (v.type === DataType.float) {\n          new Float32Array(arrayBuffer, offset, data.length).set(data);\n        } else {\n          throw new Error(`Unsupported uniform type: ${tensorDataTypeEnumToString(v.type)}`);\n        }\n      });\n\n      const uniformBufferData =\n        // eslint-disable-next-line no-bitwise\n        this.gpuDataManager.create(currentOffset, GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM);\n      this.device.queue.writeBuffer(uniformBufferData.buffer, 0, arrayBuffer, 0, currentOffset);\n      this.gpuDataManager.release(uniformBufferData.id);\n      uniformBufferBinding = { offset: 0, size: currentOffset, buffer: uniformBufferData.buffer };\n    }\n\n    const normalizedDispatchGroup = this.programManager.normalizeDispatchGroupSize(dispatchGroup);\n    const is1DimensionDispatch = normalizedDispatchGroup[1] === 1 && normalizedDispatchGroup[2] === 1;\n    // get program info\n    const key = getProgramInfoUniqueKey(program, inputTensorViews, is1DimensionDispatch);\n    let artifact = this.programManager.getArtifact(key);\n    if (!artifact) {\n      artifact = this.programManager.build(program, normalizedDispatchGroup);\n      this.programManager.setArtifact(key, artifact);\n      LOG_DEBUG('info', () => `[artifact] key: ${key}, programName: ${program.name}`);\n    }\n\n    // validate uniform variables\n    if (programUniforms && artifact.uniformVariablesInfo) {\n      if (programUniforms.length !== artifact.uniformVariablesInfo.length) {\n        throw new Error(\n          `Uniform variables count mismatch: expect ${artifact.uniformVariablesInfo.length}, got ${\n            programUniforms.length\n          } in program \"${artifact.programInfo.name}\".`,\n        );\n      }\n      for (let i = 0; i < programUniforms.length; i++) {\n        const uniform = programUniforms[i];\n        const actualType = uniform.type;\n        const actualLength = typeof uniform.data === 'number' ? 1 : uniform.data.length;\n        const [type, length] = artifact.uniformVariablesInfo[i];\n        if (actualType !== type || actualLength !== length) {\n          throw new Error(\n            `Uniform variable ${i} mismatch: expect type ${type} with size ${length}, got type ${\n              actualType\n            } with size ${actualLength} in program \"${artifact.programInfo.name}\".`,\n          );\n        }\n      }\n    }\n\n    LOG_DEBUG(\n      'info',\n      () =>\n        `[ProgramManager] run \"${program.name}\" (key=${key}) with ${normalizedDispatchGroup[0]}x${\n          normalizedDispatchGroup[1]\n        }x${normalizedDispatchGroup[2]}`,\n    );\n\n    if (this.queryType !== 'none' || this.sessionStatus === 'capturing') {\n      const pendingKernelInfo: PendingKernelInfo = {\n        kernelId: this.currentKernelId!,\n        programName: artifact.programInfo.name,\n        inputTensorViews,\n        outputTensorViews,\n      };\n      this.pendingKernels.push(pendingKernelInfo);\n\n      if (this.sessionStatus === 'capturing') {\n        const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId!);\n        sessionPendingKernels!.push(pendingKernelInfo);\n      }\n    }\n\n    this.programManager.run(artifact, inputDatas, outputDatas, normalizedDispatchGroup, uniformBufferBinding);\n\n    TRACE_FUNC_END(program.name);\n    return outputTensorViews;\n  }\n\n  upload(gpuDataId: number, data: Uint8Array): void {\n    this.gpuDataManager.upload(gpuDataId, data);\n  }\n\n  memcpy(src: number, dst: number): void {\n    this.gpuDataManager.memcpy(src, dst);\n  }\n\n  async download(gpuDataId: number, getTargetBuffer: () => Uint8Array): Promise<void> {\n    // the underlying buffer may be changed after the async function is called. so we use a getter function to make sure\n    // the buffer is up-to-date.\n    await this.gpuDataManager.download(gpuDataId, getTargetBuffer);\n  }\n\n  alloc(size: number): number {\n    return this.gpuDataManager.create(size).id;\n  }\n\n  free(ptr: number): number {\n    return this.gpuDataManager.release(ptr);\n  }\n\n  createKernel(kernelType: string, kernelId: number, attribute: unknown, kernelName: string): void {\n    const op = WEBGPU_OP_RESOLVE_RULES.get(kernelType);\n    if (!op) {\n      throw new Error(`kernel not implemented: ${kernelType}`);\n    }\n\n    const kernelInfo: KernelInfo = {\n      kernelType,\n      kernelName,\n      kernelEntry: op[0],\n      attributes: [op[1], attribute],\n    };\n    this.kernels.set(kernelId, kernelInfo);\n  }\n\n  releaseKernel(kernelId: number): void {\n    const persistentData = this.kernelPersistentData.get(kernelId);\n    if (persistentData) {\n      for (const data of persistentData) {\n        this.gpuDataManager.release(data.id);\n      }\n      this.kernelPersistentData.delete(kernelId);\n    }\n\n    this.kernelCustomData.delete(kernelId);\n    this.kernels.delete(kernelId);\n  }\n\n  computeKernel(kernelId: number, context: ComputeContext, errors: Array<Promise<string | null>>): number {\n    const kernel = this.kernels.get(kernelId);\n    if (!kernel) {\n      throw new Error(`kernel not created: ${kernelId}`);\n    }\n    const kernelType = kernel.kernelType;\n    const kernelName = kernel.kernelName;\n    const kernelEntry = kernel.kernelEntry;\n    const attributes = kernel.attributes;\n    if (this.currentKernelId !== null) {\n      throw new Error(`kernel \"[${kernelType}] ${kernelName}\" is not allowed to be called recursively`);\n    }\n    this.currentKernelId = kernelId;\n\n    // parse attributes if necessary\n    if (attributes[0]) {\n      attributes[1] = attributes[0](attributes[1]);\n      attributes[0] = undefined;\n    }\n\n    LOG_DEBUG('info', () => `[WebGPU] Start to run kernel \"[${kernelType}] ${kernelName}\"...`);\n\n    const useErrorScope = this.env.debug;\n\n    this.temporaryData = [];\n    try {\n      if (useErrorScope) {\n        this.device.pushErrorScope('validation');\n      }\n\n      kernelEntry(context, attributes[1]);\n      return 0; // ORT_OK\n    } catch (e) {\n      errors.push(Promise.resolve(`[WebGPU] Kernel \"[${kernelType}] ${kernelName}\" failed. ${e}`));\n      return 1; // ORT_FAIL\n    } finally {\n      if (useErrorScope) {\n        errors.push(\n          this.device\n            .popErrorScope()\n            .then((err) =>\n              err ? `GPU validation error for kernel \"[${kernelType}] ${kernelName}\": ${err.message}` : null,\n            ),\n        );\n      }\n\n      for (const data of this.temporaryData) {\n        this.gpuDataManager.release(data.id);\n      }\n      this.temporaryData = [];\n      this.currentKernelId = null;\n    }\n  }\n\n  // #region external buffer\n  registerBuffer(sessionId: number, index: number, buffer: GPUBuffer, size: number): number {\n    let sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId);\n    if (!sessionInputOutputMapping) {\n      sessionInputOutputMapping = new Map();\n      this.sessionExternalDataMapping.set(sessionId, sessionInputOutputMapping);\n    }\n\n    // the buffer may be user created, or managed by GPU data manager.\n    // The GPU data manager will not manage these buffers. we register them as external buffers.\n    //\n    // The map `sessionInputOutputMapping` is used to store the data ID and buffer for each input/output. Once a\n    // specific input/output is registered, the data ID will not change.\n    const previousBuffer = sessionInputOutputMapping.get(index);\n    const id = this.gpuDataManager.registerExternalBuffer(buffer, size, previousBuffer);\n    sessionInputOutputMapping.set(index, [id, buffer]);\n    return id;\n  }\n  unregisterBuffers(sessionId: number): void {\n    const sessionInputOutputMapping = this.sessionExternalDataMapping.get(sessionId);\n    if (sessionInputOutputMapping) {\n      sessionInputOutputMapping.forEach((bufferInfo) => this.gpuDataManager.unregisterExternalBuffer(bufferInfo[0]));\n      this.sessionExternalDataMapping.delete(sessionId);\n    }\n  }\n  getBuffer(gpuDataId: number): GPUBuffer {\n    const gpuData = this.gpuDataManager.get(gpuDataId);\n    if (!gpuData) {\n      throw new Error(`no GPU data for buffer: ${gpuDataId}`);\n    }\n    return gpuData.buffer;\n  }\n  createDownloader(\n    gpuBuffer: GPUBuffer,\n    size: number,\n    type: Tensor.GpuBufferDataTypes,\n  ): () => Promise<Tensor.DataType> {\n    return async () => {\n      const data = await downloadGpuData(this, gpuBuffer, size);\n      return createView(data.buffer, type);\n    };\n  }\n  // #endregion\n  writeTimestamp(index: number): void {\n    if (this.queryType !== 'inside-passes') {\n      return;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (this.computePassEncoder as any).writeTimestamp(this.querySet, index);\n  }\n  setQueryType(): void {\n    this.queryType = 'none';\n    if (\n      this.env.webgpu.profiling?.mode === 'default' ||\n      (typeof this.env.trace === 'undefined' ? this.env.wasm.trace : this.env.trace)\n    ) {\n      if (this.device.features.has('chromium-experimental-timestamp-query-inside-passes')) {\n        this.queryType = 'inside-passes';\n      } else if (this.device.features.has('timestamp-query')) {\n        this.queryType = 'at-passes';\n      }\n\n      if (this.queryType !== 'none' && typeof this.querySet === 'undefined') {\n        this.querySet = this.device.createQuerySet({\n          type: 'timestamp',\n          count: this.maxDispatchNumber * 2,\n        });\n        this.queryResolveBuffer = this.device.createBuffer(\n          // eslint-disable-next-line no-bitwise\n          { size: this.maxDispatchNumber * 2 * 8, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE },\n        );\n      }\n    }\n  }\n\n  captureBegin(): void {\n    LOG_DEBUG('info', 'captureBegin');\n    if (!this.capturedCommandList.get(this.currentSessionId!)) {\n      this.capturedCommandList.set(this.currentSessionId!, []);\n    }\n    if (!this.capturedPendingKernels.get(this.currentSessionId!)) {\n      this.capturedPendingKernels.set(this.currentSessionId!, []);\n    }\n    // flush the left commands before we change the status.\n    this.flush();\n    this.sessionStatus = 'capturing';\n  }\n  captureEnd(): void {\n    LOG_DEBUG('info', 'captureEnd');\n    // flush the left commands before we change the status.\n    this.flush();\n    this.sessionStatus = 'default';\n  }\n  replay(): void {\n    LOG_DEBUG('info', 'replay');\n    this.sessionStatus = 'replaying';\n    const sessionCommandList = this.capturedCommandList.get(this.currentSessionId!);\n    const sessionPendingKernels = this.capturedPendingKernels.get(this.currentSessionId!);\n    const length = sessionCommandList!.length;\n    this.pendingKernels = [];\n    for (let i = 0; i < length; i++) {\n      const computePassEncoder = this.getComputePassEncoder();\n      const command = sessionCommandList![i];\n      this.writeTimestamp(this.pendingDispatchNumber * 2);\n      computePassEncoder.setPipeline(command.computePipeline);\n      computePassEncoder.setBindGroup(0, command.bindGroup);\n      computePassEncoder.dispatchWorkgroups(...command.dispatchGroup);\n      this.writeTimestamp(this.pendingDispatchNumber * 2 + 1);\n      this.pendingDispatchNumber++;\n      if (this.queryType !== 'none') {\n        this.pendingKernels.push(sessionPendingKernels![i]);\n      }\n      if (this.pendingDispatchNumber >= this.maxDispatchNumber || this.queryType === 'at-passes') {\n        this.endComputePass();\n      }\n      if (this.pendingDispatchNumber >= this.maxDispatchNumber) {\n        this.flush();\n      }\n    }\n    // flush the left commands before we change the status.\n    this.flush();\n    this.sessionStatus = 'default';\n  }\n\n  onCreateSession(): void {\n    this.gpuDataManager.onCreateSession();\n  }\n\n  onReleaseSession(sessionId: number): void {\n    this.unregisterBuffers(sessionId);\n    if (this.capturedCommandList.has(sessionId)) {\n      this.capturedCommandList.delete(sessionId);\n    }\n    if (this.capturedPendingKernels.has(sessionId)) {\n      this.capturedPendingKernels.delete(sessionId);\n    }\n    this.gpuDataManager.onReleaseSession(sessionId);\n  }\n\n  onRunStart(sessionId: number): void {\n    this.currentSessionId = sessionId;\n    this.setQueryType();\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport type { Env } from 'onnxruntime-common';\n\nimport { calculateTensorSizeInBytes, DataType } from '../wasm-common';\n\nimport type { OrtWasmModule } from '../wasm-types';\n\nimport type { WebGpuBackend } from './backend-webgpu';\nimport { LOG_DEBUG } from './log';\nimport type { TensorView } from './tensor-view';\nimport { ShapeUtil } from './util';\nimport type { AdapterInfo, ComputeContext, ComputeContextInputsOutputsMapping, ProgramInfo } from './webgpu/types';\nimport { WebNNBackend } from './backend-webnn';\n\n/* eslint-disable no-bitwise */\n\nclass TensorViewImpl implements TensorView {\n  constructor(\n    private module: OrtWasmModule,\n    public readonly dataType: number,\n    public readonly data: number,\n    public readonly dims: readonly number[],\n  ) {}\n\n  getFloat32Array(): Float32Array {\n    if (this.dataType !== DataType.float) {\n      throw new Error('Invalid data type');\n    }\n    const elementCount = ShapeUtil.size(this.dims);\n    return elementCount === 0\n      ? new Float32Array()\n      : new Float32Array(this.module.HEAP8.buffer, this.data, elementCount);\n  }\n\n  getBigInt64Array(): BigInt64Array {\n    if (this.dataType !== DataType.int64) {\n      throw new Error('Invalid data type');\n    }\n    const elementCount = ShapeUtil.size(this.dims);\n    return elementCount === 0\n      ? new BigInt64Array()\n      : new BigInt64Array(this.module.HEAP8.buffer, this.data, elementCount);\n  }\n\n  getInt32Array(): Int32Array {\n    if (this.dataType !== DataType.int32) {\n      throw new Error('Invalid data type');\n    }\n    const elementCount = ShapeUtil.size(this.dims);\n    return elementCount === 0 ? new Int32Array() : new Int32Array(this.module.HEAP8.buffer, this.data, elementCount);\n  }\n\n  getUint16Array(): Uint16Array {\n    if (this.dataType !== DataType.float16 && this.dataType !== DataType.uint16) {\n      throw new Error('Invalid data type');\n    }\n    const elementCount = ShapeUtil.size(this.dims);\n    return elementCount === 0 ? new Uint16Array() : new Uint16Array(this.module.HEAP8.buffer, this.data, elementCount);\n  }\n\n  reshape(newDims: readonly number[]): TensorView {\n    if (ShapeUtil.size(newDims) !== ShapeUtil.size(this.dims)) {\n      throw new Error('Invalid new shape');\n    }\n    return new TensorViewImpl(this.module, this.dataType, this.data, newDims);\n  }\n}\n\nclass ComputeContextImpl implements ComputeContext {\n  readonly adapterInfo: AdapterInfo;\n  readonly opKernelContext: number;\n  readonly inputs: readonly TensorView[];\n  readonly outputCount: number;\n  get kernelCustomData(): { [key: string]: unknown } {\n    return this.backend.currentKernelCustomData;\n  }\n  get customDataBuffer(): Uint8Array {\n    return this.module.HEAPU8.subarray(this.customDataOffset, this.customDataOffset + this.customDataSize);\n  }\n  private customDataOffset = 0;\n  private customDataSize = 0;\n  constructor(\n    private module: OrtWasmModule,\n    private backend: WebGpuBackend,\n    contextDataOffset: number,\n  ) {\n    this.adapterInfo = backend.adapterInfo;\n\n    // extract context data\n    const ptrSize = module.PTR_SIZE;\n    let dataIndex = contextDataOffset / module.PTR_SIZE;\n    const type = ptrSize === 4 ? 'i32' : 'i64';\n    this.opKernelContext = Number(module.getValue(ptrSize * dataIndex++, type));\n    const inputCount = Number(module.getValue(ptrSize * dataIndex++, type));\n    this.outputCount = Number(module.getValue(ptrSize * dataIndex++, type));\n    this.customDataOffset = Number(module.getValue(ptrSize * dataIndex++, '*'));\n    this.customDataSize = Number(module.getValue(ptrSize * dataIndex++, type));\n\n    const inputs: TensorView[] = [];\n    for (let i = 0; i < inputCount; i++) {\n      const dataType = Number(module.getValue(ptrSize * dataIndex++, type));\n      const data = Number(module.getValue(ptrSize * dataIndex++, '*'));\n      const dim = Number(module.getValue(ptrSize * dataIndex++, type));\n      const dims: number[] = [];\n      for (let d = 0; d < dim; d++) {\n        dims.push(Number(module.getValue(ptrSize * dataIndex++, type)));\n      }\n      inputs.push(new TensorViewImpl(module, dataType, data, dims));\n    }\n    this.inputs = inputs;\n  }\n\n  compute(program: ProgramInfo, inputsOutputsMapping?: ComputeContextInputsOutputsMapping): TensorView[] {\n    // prepare inputs. inputs should always be valid data.\n    const mappedInputs =\n      inputsOutputsMapping?.inputs?.map((i) => (typeof i === 'number' ? this.inputs[i] : i)) ?? this.inputs;\n    // prepare outputs.\n    const outputIndices = inputsOutputsMapping?.outputs ?? [];\n    const createKernelOutput = (index: number, dataType: number, dims: readonly number[]): TensorView =>\n      new TensorViewImpl(this.module, dataType, this.output(index, dims), dims);\n    const createTemporaryOutput = (dataType: number, dims: readonly number[]): TensorView => {\n      const bufferSize = calculateTensorSizeInBytes(dataType, dims);\n      if (!bufferSize) {\n        throw new Error(`Unsupported data type: ${dataType}`);\n      }\n      const gpuDataId = bufferSize > 0 ? this.backend.gpuDataManager.create(bufferSize).id : 0;\n      return new TensorViewImpl(this.module, dataType, gpuDataId, dims);\n    };\n    return this.backend.run(\n      program,\n      mappedInputs,\n      outputIndices,\n      createKernelOutput,\n      createTemporaryOutput,\n      this.outputCount,\n    );\n  }\n\n  output(index: number, dims: readonly number[]): number {\n    const stack = this.module.stackSave();\n    try {\n      const ptrSize = this.module.PTR_SIZE;\n      const type = ptrSize === 4 ? 'i32' : 'i64';\n      const data = this.module.stackAlloc((1 + dims.length) * ptrSize /* sizeof(size_t) */);\n      this.module.setValue(data, dims.length, type);\n      for (let i = 0; i < dims.length; i++) {\n        this.module.setValue(data + ptrSize * (i + 1), dims[i], type);\n      }\n      return this.module._JsepOutput!(this.opKernelContext, index, data);\n    } catch (e) {\n      throw new Error(\n        `Failed to generate kernel's output[${index}] with dims [${dims}]. ` +\n          'If you are running with pre-allocated output, please make sure the output type/dims are correct. ' +\n          `Error: ${e}`,\n      );\n    } finally {\n      this.module.stackRestore(stack);\n    }\n  }\n}\n\n/**\n * Initialize JSEP with WebGPU backend.\n *\n * This function will be called after the WebAssembly module is loaded and initialized (\"_OrtInit\" is called), once for\n * each of the following EPs if they are specified:\n * - \"webgpu\"\n * - \"webnn\"\n *\n * For WebGPU, this function expects:\n *  - WebGPU is enabled in build (BUILD_DEFS.DISABLE_JSEP === false).\n *  - WebGPU is available in current environment. (a valid GPUAdapter is passed in)\n *\n * For WebNN, this function expects:\n * - WebNN is enabled in build (BUILD_DEFS.DISABLE_JSEP === false).\n * - WebNN is available in current environment. (navigator.ml is not undefined)\n *\n * If the WebAssembly module is not built with JSEP support, this function will throw an error. This will invalidate\n * 'webgpu'/'webnn' backend.\n *\n * @param name - the name of the EP, either \"webgpu\" or \"webnn\"\n * @param module - the ORT WebAssembly module\n * @param env - the ORT environment variable (ort.env)\n * @param gpuAdapter - the pre-created GPU adapter\n */\nexport const init = async (\n  name: 'webgpu' | 'webnn',\n  module: OrtWasmModule,\n  env: Env,\n  gpuAdapter?: GPUAdapter,\n): Promise<void> => {\n  const jsepInit = module.jsepInit;\n  if (!jsepInit) {\n    throw new Error('Failed to initialize JSEP. The WebAssembly module is not built with JSEP support.');\n  }\n\n  if (name === 'webgpu') {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n    const webGpuBackendImpl = require('./backend-webgpu').WebGpuBackend;\n    const backend = new webGpuBackendImpl();\n    await backend.initialize(env, gpuAdapter!);\n\n    jsepInit('webgpu', [\n      // backend\n      backend,\n\n      // jsepAlloc()\n      (size: number) => backend.alloc(Number(size)),\n\n      // jsepFree()\n      (ptr: number) => backend.free(ptr),\n\n      // jsepCopy(src, dst, size, isSourceGpu)\n      (src: number, dst: number, size: number, isSourceGpu = false) => {\n        if (isSourceGpu) {\n          LOG_DEBUG(\n            'verbose',\n            () => `[WebGPU] jsepCopyGpuToGpu: src=${Number(src)}, dst=${Number(dst)}, size=${Number(size)}`,\n          );\n          backend.memcpy(Number(src), Number(dst));\n        } else {\n          LOG_DEBUG(\n            'verbose',\n            () =>\n              `[WebGPU] jsepCopyCpuToGpu: dataOffset=${Number(src)}, gpuDataId=${Number(dst)}, size=${Number(size)}`,\n          );\n          const data = module.HEAPU8.subarray(Number(src >>> 0), Number(src >>> 0) + Number(size));\n          backend.upload(Number(dst), data);\n        }\n      },\n\n      // jsepCopyAsync(src, dst, size)\n      async (gpuDataId: number, dataOffset: number, size: number): Promise<void> => {\n        LOG_DEBUG(\n          'verbose',\n          () => `[WebGPU] jsepCopyGpuToCpu: gpuDataId=${gpuDataId}, dataOffset=${dataOffset}, size=${size}`,\n        );\n\n        await backend.download(Number(gpuDataId), () =>\n          module.HEAPU8.subarray(Number(dataOffset) >>> 0, Number(dataOffset + size) >>> 0),\n        );\n      },\n\n      // jsepCreateKernel\n      (kernelType: string, kernelId: number, attribute: unknown) =>\n        backend.createKernel(\n          kernelType,\n          Number(kernelId),\n          attribute,\n          module.UTF8ToString(module._JsepGetNodeName!(Number(kernelId))),\n        ),\n\n      // jsepReleaseKernel\n      (kernel: number) => backend.releaseKernel(kernel),\n\n      // jsepRun\n      (kernel: number, contextDataOffset: number, sessionHandle: number, errors: Array<Promise<string | null>>) => {\n        LOG_DEBUG(\n          'verbose',\n          () =>\n            `[WebGPU] jsepRun: sessionHandle=${sessionHandle}, kernel=${kernel}, contextDataOffset=${contextDataOffset}`,\n        );\n        const context = new ComputeContextImpl(module, backend, Number(contextDataOffset));\n        return backend.computeKernel(Number(kernel), context, errors);\n      },\n      // jsepCaptureBegin\n      () => backend.captureBegin(),\n      // jsepCaptureEnd\n      () => backend.captureEnd(),\n      // jsepReplay\n      () => backend.replay(),\n    ]);\n  } else {\n    const backend = new WebNNBackend(env);\n    jsepInit('webnn', [\n      backend,\n      // webnnReserveTensorId\n      () => backend.reserveTensorId(),\n      // webnnReleaseTensorId\n      (tensorId: number) => backend.releaseTensorId(tensorId),\n      // webnnEnsureTensor\n      async (\n        sessionId: number | undefined,\n        tensorId: number,\n        onnxDataType: number,\n        shape: number[],\n        copyOld: boolean,\n      ) => backend.ensureTensor(sessionId, tensorId, onnxDataType, shape, copyOld),\n      // webnnUploadTensor\n      (tensorId: number, data: Uint8Array) => {\n        backend.uploadTensor(tensorId, data);\n      },\n      // webnnDownloadTensor\n      async (tensorId: number, dstBuffer: ArrayBufferView | ArrayBuffer) => backend.downloadTensor(tensorId, dstBuffer),\n      // webnnRegisterMLContext\n      (sessionId: number, mlContext: MLContext) => backend.registerMLContext(sessionId, mlContext),\n      // webnnEnableTraceEvent\n      !!env.trace,\n    ]);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n// WebNN API currently does not have a TypeScript definition file. This file is a workaround with types generated from\n// WebNN API specification.\n// https://github.com/webmachinelearning/webnn/issues/677\n/// <reference path=\"jsep/webnn/webnn.d.ts\" />\n\nimport { Env, InferenceSession, Tensor, TRACE_EVENT_BEGIN, TRACE_EVENT_END } from 'onnxruntime-common';\n\nimport {\n  SerializableInternalBuffer,\n  SerializableSessionMetadata,\n  SerializableTensorMetadata,\n  TensorMetadata,\n} from './proxy-messages';\nimport { setRunOptions } from './run-options';\nimport { setSessionOptions } from './session-options';\nimport {\n  calculateTensorSizeInBytes,\n  dataLocationStringToEnum,\n  isGpuBufferSupportedType,\n  isMLTensorSupportedType,\n  logLevelStringToEnum,\n  tensorDataTypeEnumToString,\n  tensorDataTypeStringToEnum,\n  tensorTypeToTypedArrayConstructor,\n} from './wasm-common';\nimport { getInstance } from './wasm-factory';\nimport { allocWasmString, checkLastError } from './wasm-utils';\nimport { loadFile } from './wasm-utils-load-file';\n\n// #region Initializations\n\n/**\n * There are 4 different \"initialization\" steps for ORT. They happen in different places and different time.\n *\n * 1. JavaScript initialization for onnxruntime-common and onnxruntime-web.\n *    This is the first initialization step. In this step, onnxruntime-web calls onnxruntime-common's registerBackend()\n * function multiple times to register all the available backends. The backend registration is very fast. It only\n * registers the backend name with the uninitialized backend object. No heavy initialization is done in this step.\n *    Refer to web/lib/index.ts for the backend registration.\n *\n * 2. WebAssembly artifact initialization.\n *    This happens when any registered wasm backend is used for the first time (ie. `ort.InferenceSession.create()` is\n * called). In this step, onnxruntime-web does the followings:\n *     - create a proxy worker and make sure the proxy worker is ready to receive messages, if proxy is enabled.\n *     - perform feature detection, locate correct WebAssembly artifact path and call the Emscripten generated\n * JavaScript code to initialize the WebAssembly runtime.\n *         - if proxy is enabled, this step happens in the proxy worker using message 'init-wasm'.\n *         - downloading the 'ort-wasm{...}.wasm' file is done in this step.\n *         - if multi-thread is enabled, one or more webworker will be created to initialize the PThread threadpool.\n *\n * 3. ORT environment initialization.\n *    This happens after step 2. In this step, onnxruntime-web performs ONNX Runtime environment initialization.\n * Function `_OrtInit()` is called in this step.\n *     - if proxy is enabled, this step happens in the proxy worker using message 'init-ort'.\n *     - logging level (ort.env.logLevel) and thread number (ort.env.wasm.numThreads) are set in this step.\n *\n * 4. Session initialization.\n *    This happens when `ort.InferenceSession.create()` is called. Unlike the first 3 steps (they only called once),\n * this step will be done for each session. In this step, onnxruntime-web does the followings:\n *    If the parameter is a URL:\n *    - download the model data from the URL.\n *    - copy the model data to the WASM heap. (proxy: 'copy-from')\n *    - dereference the model buffer. This step allows the original ArrayBuffer to be garbage collected.\n *    - call `_OrtCreateSession()` to create the session. (proxy: 'create')\n *\n *    If the parameter is a Uint8Array object:\n *    - copy the model data to the WASM heap. (proxy: 'copy-from')\n *    - call `_OrtCreateSession()` to create the session. (proxy: 'create')\n *\n *\n */\n\n/**\n * initialize ORT environment.\n *\n * @param numThreads SetGlobalIntraOpNumThreads(numThreads)\n * @param loggingLevel CreateEnv(static_cast<OrtLoggingLevel>(logging_level))\n */\nconst initOrt = (numThreads: number, loggingLevel: number): void => {\n  const errorCode = getInstance()._OrtInit(numThreads, loggingLevel);\n  if (errorCode !== 0) {\n    checkLastError(\"Can't initialize onnxruntime.\");\n  }\n};\n\n/**\n * initialize runtime environment.\n * @param env passed in the environment config object.\n */\nexport const initRuntime = async (env: Env): Promise<void> => {\n  // init ORT\n  initOrt(env.wasm.numThreads!, logLevelStringToEnum(env.logLevel));\n};\n\n/**\n * perform EP specific initialization.\n *\n * @param env\n * @param epName\n */\nexport const initEp = async (env: Env, epName: string): Promise<void> => {\n  // initialize ASYNCIFY support\n  getInstance().asyncInit?.();\n\n  // perform WebGPU availability check ( either JSEP or WebGPU EP )\n  let webgpuAdapter = env.webgpu.adapter as GPUAdapter | null;\n  if (epName === 'webgpu') {\n    if (typeof navigator === 'undefined' || !navigator.gpu) {\n      throw new Error('WebGPU is not supported in current environment');\n    }\n    if (!webgpuAdapter) {\n      // if adapter is not set, request a new adapter.\n      const powerPreference = env.webgpu.powerPreference;\n      if (powerPreference !== undefined && powerPreference !== 'low-power' && powerPreference !== 'high-performance') {\n        throw new Error(`Invalid powerPreference setting: \"${powerPreference}\"`);\n      }\n      const forceFallbackAdapter = env.webgpu.forceFallbackAdapter;\n      if (forceFallbackAdapter !== undefined && typeof forceFallbackAdapter !== 'boolean') {\n        throw new Error(`Invalid forceFallbackAdapter setting: \"${forceFallbackAdapter}\"`);\n      }\n      webgpuAdapter = await navigator.gpu.requestAdapter({ powerPreference, forceFallbackAdapter });\n      if (!webgpuAdapter) {\n        throw new Error(\n          'Failed to get GPU adapter. ' +\n            'You may need to enable flag \"--enable-unsafe-webgpu\" if you are using Chrome.',\n        );\n      }\n    } else {\n      // if adapter is set, validate it.\n      if (\n        typeof webgpuAdapter.limits !== 'object' ||\n        typeof webgpuAdapter.features !== 'object' ||\n        typeof webgpuAdapter.requestDevice !== 'function'\n      ) {\n        throw new Error('Invalid GPU adapter set in `env.webgpu.adapter`. It must be a GPUAdapter object.');\n      }\n    }\n  }\n\n  // perform WebNN availability check ( either JSEP or WebNN EP )\n  if (epName === 'webnn') {\n    if (typeof navigator === 'undefined' || !(navigator as unknown as { ml: unknown }).ml) {\n      throw new Error('WebNN is not supported in current environment');\n    }\n  }\n\n  if (!BUILD_DEFS.DISABLE_JSEP) {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n    const initJsep = require('./jsep/init').init;\n\n    if (epName === 'webgpu') {\n      await initJsep('webgpu', getInstance(), env, webgpuAdapter);\n    }\n    if (epName === 'webnn') {\n      await initJsep('webnn', getInstance(), env);\n    }\n  } else {\n    if (!BUILD_DEFS.DISABLE_WEBGPU && epName === 'webgpu') {\n      getInstance().webgpuInit!((device) => {\n        env.webgpu.device = device;\n      });\n    }\n    if (!BUILD_DEFS.DISABLE_WEBNN && epName === 'webnn') {\n      // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires\n      const backend = new (require('./jsep/backend-webnn').WebNNBackend)(env);\n      getInstance().webnnInit!([\n        backend,\n        // webnnReserveTensorId\n        () => backend.reserveTensorId(),\n        // webnnReleaseTensorId,\n        (tensorId: number) => backend.releaseTensorId(tensorId),\n        // webnnEnsureTensor\n        async (sessionId: number | undefined, tensorId: number, onnxDataType: number, shape: number[], copyOld) =>\n          backend.ensureTensor(sessionId, tensorId, onnxDataType, shape, copyOld),\n        // webnnUploadTensor\n        (tensorId: number, data: Uint8Array) => {\n          backend.uploadTensor(tensorId, data);\n        },\n        // webnnDownloadTensor\n        async (tensorId: number, dstBuffer: ArrayBufferView | ArrayBuffer) =>\n          backend.downloadTensor(tensorId, dstBuffer),\n        // webnnRegisterMLContext\n        (sessionId: number, mlContext: MLContext) => backend.registerMLContext(sessionId, mlContext),\n        // webnnEnableTraceEvent\n        !!env.trace,\n      ]);\n    }\n  }\n};\n\n// #endregion Initializations\n\n/**\n * valid data locations for input/output tensors.\n */\ntype SupportedTensorDataLocationForInputOutput =\n  | 'cpu'\n  | 'cpu-pinned'\n  | 'gpu-buffer'\n  | 'ml-tensor'\n  // Use 'ml-tensor' during inference, but output a tensor located on the CPU.\n  | 'ml-tensor-cpu-output';\n\ntype IOBindingState = {\n  /**\n   * the handle of IO binding.\n   */\n  readonly handle: number;\n\n  /**\n   * the preferred location for each output tensor.\n   *\n   * value is one of 'cpu', 'cpu-pinned', 'gpu-buffer', 'ml-tensor'.\n   */\n  readonly outputPreferredLocations: readonly SupportedTensorDataLocationForInputOutput[];\n\n  /**\n   * enum value of the preferred location for each output tensor.\n   */\n  readonly outputPreferredLocationsEncoded: readonly number[];\n};\n\n/**\n *  tuple elements are: InferenceSession ID; inputNamesUTF8Encoded; outputNamesUTF8Encoded; bindingState\n */\ntype SessionMetadata = [\n  inferenceSessionId: number,\n  inputNamesUTF8Encoded: number[],\n  outputNamesUTF8Encoded: number[],\n  bindingState: IOBindingState | null,\n  enableGraphCapture: boolean,\n  inputOutputBound: boolean,\n];\n\nconst activeSessions = new Map<number, SessionMetadata>();\n\n/**\n * get the input/output count of the session.\n * @param sessionHandle the handle representing the session. should be non-zero.\n * @returns a tuple including 2 numbers, representing the input count and output count.\n */\nconst getSessionInputOutputCount = (sessionHandle: number): [number, number] => {\n  const wasm = getInstance();\n  const stack = wasm.stackSave();\n  try {\n    const ptrSize = wasm.PTR_SIZE;\n    const dataOffset = wasm.stackAlloc(2 * ptrSize);\n    const errorCode = wasm._OrtGetInputOutputCount(sessionHandle, dataOffset, dataOffset + ptrSize);\n    if (errorCode !== 0) {\n      checkLastError(\"Can't get session input/output count.\");\n    }\n    const type = ptrSize === 4 ? 'i32' : 'i64';\n    return [Number(wasm.getValue(dataOffset, type)), Number(wasm.getValue(dataOffset + ptrSize, type))];\n  } finally {\n    wasm.stackRestore(stack);\n  }\n};\n\nconst getSessionInputOutputMetadata = (\n  sessionHandle: number,\n  index: number,\n): [nameOffset: number, elementType: number, dims?: Array<number | string>] => {\n  const wasm = getInstance();\n  const stack = wasm.stackSave();\n  let metadataOffset = 0;\n  try {\n    const ptrSize = wasm.PTR_SIZE;\n    const dataOffset = wasm.stackAlloc(2 * ptrSize);\n    const errorCode = wasm._OrtGetInputOutputMetadata(sessionHandle, index, dataOffset, dataOffset + ptrSize);\n    if (errorCode !== 0) {\n      checkLastError(\"Can't get session input/output metadata.\");\n    }\n    const nameOffset = Number(wasm.getValue(dataOffset, '*'));\n    metadataOffset = Number(wasm.getValue(dataOffset + ptrSize, '*'));\n    // get element type\n    const elementType = wasm.HEAP32[metadataOffset / 4];\n    if (elementType === 0) {\n      return [nameOffset, 0]; // non-tensor\n    }\n\n    // get dims count\n    const dimsCount = wasm.HEAPU32[metadataOffset / 4 + 1];\n    // get dims\n    const dims: Array<number | string> = [];\n    for (let i = 0; i < dimsCount; i++) {\n      const symbolicDimNameOffset = Number(wasm.getValue(metadataOffset + 8 + i * ptrSize, '*'));\n      dims.push(\n        symbolicDimNameOffset !== 0\n          ? wasm.UTF8ToString(symbolicDimNameOffset)\n          : Number(wasm.getValue(metadataOffset + 8 + (i + dimsCount) * ptrSize, '*')),\n      );\n    }\n    return [nameOffset, elementType, dims];\n  } finally {\n    wasm.stackRestore(stack);\n    if (metadataOffset !== 0) {\n      wasm._OrtFree(metadataOffset);\n    }\n  }\n};\n\n/**\n * allocate the memory and memcpy the external buffer.\n *\n * @param model - the external buffer containing the model data. Must not be the same buffer as the WASM heap.\n * @returns a 2-elements tuple - the pointer and size of the allocated buffer\n */\nexport const copyFromExternalBuffer = (model: Uint8Array): [number, number] => {\n  const wasm = getInstance();\n  const modelDataOffset = wasm._malloc(model.byteLength);\n  if (modelDataOffset === 0) {\n    throw new Error(`Can't create a session. failed to allocate a buffer of size ${model.byteLength}.`);\n  }\n  wasm.HEAPU8.set(model, modelDataOffset);\n  return [modelDataOffset, model.byteLength];\n};\n\n/**\n * create an inference session from a model data buffer.\n *\n * @param modelData - either a Uint8Array object representing the model data, or a 2-elements tuple containing the\n *     pointer and size of the model data buffer.\n * @param options an optional session options object.\n * @returns a 3-elements tuple containing [session handle, input names, output names]\n */\nexport const createSession = async (\n  modelData: Uint8Array | SerializableInternalBuffer,\n  options?: InferenceSession.SessionOptions,\n): Promise<SerializableSessionMetadata> => {\n  let modelDataOffset: number, modelDataLength: number;\n  const wasm = getInstance();\n\n  if (Array.isArray(modelData)) {\n    // if model data is an array, it must be a 2-elements tuple containing the pointer and size of the model data\n    [modelDataOffset, modelDataLength] = modelData;\n  } else if (modelData.buffer === wasm.HEAPU8.buffer) {\n    // if model data uses the same buffer as the WASM heap, we don't need to copy it.\n    [modelDataOffset, modelDataLength] = [modelData.byteOffset, modelData.byteLength];\n  } else {\n    // otherwise, copy the model data to the WASM heap.\n    [modelDataOffset, modelDataLength] = copyFromExternalBuffer(modelData);\n  }\n\n  let sessionHandle = 0;\n  let sessionOptionsHandle = 0;\n  let ioBindingHandle = 0;\n  let allocs: number[] = [];\n  const inputNamesUTF8Encoded = [];\n  const outputNamesUTF8Encoded = [];\n\n  try {\n    [sessionOptionsHandle, allocs] = await setSessionOptions(options);\n\n    if (options?.externalData && wasm.mountExternalData) {\n      const loadingPromises = [];\n      for (const file of options.externalData) {\n        const path = typeof file === 'string' ? file : file.path;\n        loadingPromises.push(\n          loadFile(typeof file === 'string' ? file : file.data).then((data) => {\n            wasm.mountExternalData(path, data);\n          }),\n        );\n      }\n\n      // wait for all external data files to be loaded\n      await Promise.all(loadingPromises);\n    }\n\n    for (const provider of options?.executionProviders ?? []) {\n      const providerName = typeof provider === 'string' ? provider : provider.name;\n      if (providerName === 'webnn') {\n        wasm.shouldTransferToMLTensor = false;\n        if (typeof provider !== 'string') {\n          const webnnOptions = provider as InferenceSession.WebNNExecutionProviderOption;\n          const context = (webnnOptions as InferenceSession.WebNNOptionsWithMLContext)?.context;\n          const gpuDevice = (webnnOptions as InferenceSession.WebNNOptionsWebGpu)?.gpuDevice;\n          const deviceType = (webnnOptions as InferenceSession.WebNNContextOptions)?.deviceType;\n          const powerPreference = (webnnOptions as InferenceSession.WebNNContextOptions)?.powerPreference;\n          if (context) {\n            wasm.currentContext = context as MLContext;\n          } else if (gpuDevice) {\n            wasm.currentContext = await wasm.webnnCreateMLContext!(gpuDevice);\n          } else {\n            wasm.currentContext = await wasm.webnnCreateMLContext!({ deviceType, powerPreference });\n          }\n        } else {\n          wasm.currentContext = await wasm.webnnCreateMLContext!();\n        }\n        break;\n      }\n    }\n\n    sessionHandle = await wasm._OrtCreateSession(modelDataOffset, modelDataLength, sessionOptionsHandle);\n    wasm.webgpuOnCreateSession?.(sessionHandle);\n    if (sessionHandle === 0) {\n      checkLastError(\"Can't create a session.\");\n    }\n\n    wasm.jsepOnCreateSession?.();\n\n    // clear current MLContext after session creation\n    if (wasm.currentContext) {\n      wasm.webnnRegisterMLContext!(sessionHandle, wasm.currentContext);\n      wasm.currentContext = undefined;\n      wasm.shouldTransferToMLTensor = true;\n    }\n\n    const [inputCount, outputCount] = getSessionInputOutputCount(sessionHandle);\n\n    const enableGraphCapture = !!options?.enableGraphCapture;\n\n    const inputNames = [];\n    const outputNames = [];\n    const inputMetadata: InferenceSession.ValueMetadata[] = [];\n    const outputMetadata: InferenceSession.ValueMetadata[] = [];\n    const outputPreferredLocations: SupportedTensorDataLocationForInputOutput[] = [];\n    for (let i = 0; i < inputCount; i++) {\n      const [nameOffset, elementType, shape] = getSessionInputOutputMetadata(sessionHandle, i);\n      if (nameOffset === 0) {\n        checkLastError(\"Can't get an input name.\");\n      }\n      inputNamesUTF8Encoded.push(nameOffset);\n      const name = wasm.UTF8ToString(nameOffset);\n      inputNames.push(name);\n      inputMetadata.push(\n        elementType === 0\n          ? { name, isTensor: false }\n          : { name, isTensor: true, type: tensorDataTypeEnumToString(elementType), shape: shape! },\n      );\n    }\n    for (let i = 0; i < outputCount; i++) {\n      const [nameOffset, elementType, shape] = getSessionInputOutputMetadata(sessionHandle, i + inputCount);\n      if (nameOffset === 0) {\n        checkLastError(\"Can't get an output name.\");\n      }\n      outputNamesUTF8Encoded.push(nameOffset);\n      const nameString = wasm.UTF8ToString(nameOffset);\n      outputNames.push(nameString);\n      outputMetadata.push(\n        elementType === 0\n          ? { name: nameString, isTensor: false }\n          : { name: nameString, isTensor: true, type: tensorDataTypeEnumToString(elementType), shape: shape! },\n      );\n\n      if (!BUILD_DEFS.DISABLE_JSEP || !BUILD_DEFS.DISABLE_WEBGPU) {\n        if (enableGraphCapture && options?.preferredOutputLocation === undefined) {\n          outputPreferredLocations.push('gpu-buffer');\n          continue;\n        }\n        const location =\n          typeof options?.preferredOutputLocation === 'string'\n            ? options.preferredOutputLocation\n            : (options?.preferredOutputLocation?.[nameString] ?? 'cpu');\n        const isGraphOutput = wasm.webnnIsGraphOutput;\n        if (location === 'cpu' && isGraphOutput && isGraphOutput(sessionHandle, nameString)) {\n          outputPreferredLocations.push('ml-tensor-cpu-output');\n          continue;\n        }\n        if (location !== 'cpu' && location !== 'cpu-pinned' && location !== 'gpu-buffer' && location !== 'ml-tensor') {\n          throw new Error(`Not supported preferred output location: ${location}.`);\n        }\n        if (enableGraphCapture && location !== 'gpu-buffer') {\n          throw new Error(\n            `Not supported preferred output location: ${location}. Only 'gpu-buffer' location is supported when enableGraphCapture is true.`,\n          );\n        }\n        outputPreferredLocations.push(location);\n      }\n    }\n\n    // use IO binding only when at least one output is preferred to be on GPU.\n    let bindingState: IOBindingState | null = null;\n    if (\n      (!BUILD_DEFS.DISABLE_JSEP || !BUILD_DEFS.DISABLE_WEBGPU) &&\n      outputPreferredLocations.some((l) => l === 'gpu-buffer' || l === 'ml-tensor' || l === 'ml-tensor-cpu-output')\n    ) {\n      ioBindingHandle = wasm._OrtCreateBinding(sessionHandle);\n      if (ioBindingHandle === 0) {\n        checkLastError(\"Can't create IO binding.\");\n      }\n\n      bindingState = {\n        handle: ioBindingHandle,\n        outputPreferredLocations,\n        outputPreferredLocationsEncoded: outputPreferredLocations\n          // 'ml-tensor-cpu-output' is treated as 'ml-tensor' for the purpose of IO binding.\n          .map((l) => (l === 'ml-tensor-cpu-output' ? 'ml-tensor' : l))\n          .map((l) => dataLocationStringToEnum(l)),\n      };\n    }\n\n    activeSessions.set(sessionHandle, [\n      sessionHandle,\n      inputNamesUTF8Encoded,\n      outputNamesUTF8Encoded,\n      bindingState,\n      enableGraphCapture,\n      false,\n    ]);\n    return [sessionHandle, inputNames, outputNames, inputMetadata, outputMetadata];\n  } catch (e) {\n    inputNamesUTF8Encoded.forEach((buf) => wasm._OrtFree(buf));\n    outputNamesUTF8Encoded.forEach((buf) => wasm._OrtFree(buf));\n\n    if (ioBindingHandle !== 0) {\n      if (wasm._OrtReleaseBinding(ioBindingHandle) !== 0) {\n        checkLastError(\"Can't release IO binding.\");\n      }\n    }\n\n    if (sessionHandle !== 0) {\n      if (wasm._OrtReleaseSession(sessionHandle) !== 0) {\n        checkLastError(\"Can't release session.\");\n      }\n    }\n    throw e;\n  } finally {\n    wasm._free(modelDataOffset);\n    if (sessionOptionsHandle !== 0) {\n      if (wasm._OrtReleaseSessionOptions(sessionOptionsHandle) !== 0) {\n        checkLastError(\"Can't release session options.\");\n      }\n    }\n    allocs.forEach((alloc) => wasm._free(alloc));\n\n    // unmount external data if necessary\n    wasm.unmountExternalData?.();\n  }\n};\n\nexport const releaseSession = (sessionId: number): void => {\n  const wasm = getInstance();\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error(`cannot release session. invalid session id: ${sessionId}`);\n  }\n  const [sessionHandle, inputNamesUTF8Encoded, outputNamesUTF8Encoded, ioBindingState, enableGraphCapture] = session;\n\n  if (ioBindingState) {\n    if (enableGraphCapture) {\n      if (wasm._OrtClearBoundOutputs(ioBindingState.handle) !== 0) {\n        checkLastError(\"Can't clear bound outputs.\");\n      }\n    }\n    if (wasm._OrtReleaseBinding(ioBindingState.handle) !== 0) {\n      checkLastError(\"Can't release IO binding.\");\n    }\n  }\n\n  wasm.jsepOnReleaseSession?.(sessionId);\n  wasm.webnnOnReleaseSession?.(sessionId);\n  wasm.webgpuOnReleaseSession?.(sessionId);\n\n  inputNamesUTF8Encoded.forEach((buf) => wasm._OrtFree(buf));\n  outputNamesUTF8Encoded.forEach((buf) => wasm._OrtFree(buf));\n  if (wasm._OrtReleaseSession(sessionHandle) !== 0) {\n    checkLastError(\"Can't release session.\");\n  }\n  activeSessions.delete(sessionId);\n};\n\nexport const prepareInputOutputTensor = async (\n  tensor: TensorMetadata | null,\n  tensorHandles: number[],\n  allocs: number[],\n  sessionId: number,\n  tensorNameUTF8Encoded: number,\n  index: number,\n  enableGraphCapture = false,\n): Promise<void> => {\n  if (!tensor) {\n    tensorHandles.push(0);\n    return;\n  }\n\n  const wasm = getInstance();\n  const ptrSize = wasm.PTR_SIZE;\n\n  const dataType = tensor[0];\n  const dims = tensor[1];\n  const location = tensor[3];\n  let actualLocation = location;\n\n  let rawData: number;\n  let dataByteLength: number;\n\n  if (dataType === 'string' && (location === 'gpu-buffer' || location === 'ml-tensor')) {\n    throw new Error('String tensor is not supported on GPU.');\n  }\n\n  if (enableGraphCapture && location !== 'gpu-buffer') {\n    throw new Error(\n      `External buffer must be provided for input/output index ${index} when enableGraphCapture is true.`,\n    );\n  }\n\n  if (location === 'gpu-buffer') {\n    const gpuBuffer = tensor[2].gpuBuffer;\n    dataByteLength = calculateTensorSizeInBytes(tensorDataTypeStringToEnum(dataType), dims)!;\n\n    if (!BUILD_DEFS.DISABLE_WEBGPU) {\n      const registerBuffer = wasm.webgpuRegisterBuffer;\n      if (!registerBuffer) {\n        throw new Error('Tensor location \"gpu-buffer\" is not supported without using WebGPU.');\n      }\n\n      rawData = registerBuffer(gpuBuffer, sessionId);\n    } else {\n      const registerBuffer = wasm.jsepRegisterBuffer;\n      if (!registerBuffer) {\n        throw new Error('Tensor location \"gpu-buffer\" is not supported without using WebGPU.');\n      }\n      rawData = registerBuffer(sessionId, index, gpuBuffer, dataByteLength);\n    }\n  } else if (location === 'ml-tensor') {\n    const mlTensor = tensor[2].mlTensor as MLTensor;\n    dataByteLength = calculateTensorSizeInBytes(tensorDataTypeStringToEnum(dataType), dims)!;\n\n    const registerMLTensor = wasm.webnnRegisterMLTensor;\n    if (!registerMLTensor) {\n      throw new Error('Tensor location \"ml-tensor\" is not supported without using WebNN.');\n    }\n    rawData = registerMLTensor(sessionId, mlTensor, tensorDataTypeStringToEnum(dataType), dims);\n  } else {\n    const data = tensor[2];\n\n    if (Array.isArray(data)) {\n      // string tensor\n      dataByteLength = ptrSize * data.length;\n      rawData = wasm._malloc(dataByteLength);\n      allocs.push(rawData);\n      for (let i = 0; i < data.length; i++) {\n        if (typeof data[i] !== 'string') {\n          throw new TypeError(`tensor data at index ${i} is not a string`);\n        }\n        wasm.setValue(rawData + i * ptrSize, allocWasmString(data[i], allocs), '*');\n      }\n    } else {\n      const isGraphInput = wasm.webnnIsGraphInput;\n      const isGraphOutput = wasm.webnnIsGraphOutput;\n      if (dataType !== 'string' && isGraphInput && isGraphOutput) {\n        const tensorName = wasm.UTF8ToString(tensorNameUTF8Encoded);\n        // Promote the tensor to 'ml-tensor' if it is a graph input.\n        if (isGraphInput(sessionId, tensorName) || isGraphOutput(sessionId, tensorName)) {\n          const dataTypeEnum = tensorDataTypeStringToEnum(dataType);\n          dataByteLength = calculateTensorSizeInBytes(dataTypeEnum, dims)!;\n          actualLocation = 'ml-tensor';\n          const createTemporaryTensor = wasm.webnnCreateTemporaryTensor;\n          const uploadTensor = wasm.webnnUploadTensor;\n          if (!createTemporaryTensor || !uploadTensor) {\n            throw new Error('Tensor location \"ml-tensor\" is not supported without using WebNN.');\n          }\n          const tensorId = await createTemporaryTensor(sessionId, dataTypeEnum, dims as number[]);\n          uploadTensor(tensorId, new Uint8Array(data.buffer, data.byteOffset, data.byteLength));\n          rawData = tensorId;\n        } else {\n          dataByteLength = data.byteLength;\n          rawData = wasm._malloc(dataByteLength);\n          allocs.push(rawData);\n          wasm.HEAPU8.set(new Uint8Array(data.buffer, data.byteOffset, dataByteLength), rawData);\n        }\n      } else {\n        dataByteLength = data.byteLength;\n        rawData = wasm._malloc(dataByteLength);\n        allocs.push(rawData);\n        wasm.HEAPU8.set(new Uint8Array(data.buffer, data.byteOffset, dataByteLength), rawData);\n      }\n    }\n  }\n\n  const stack = wasm.stackSave();\n  const dimsOffset = wasm.stackAlloc(4 * dims.length);\n  try {\n    dims.forEach((d, index) => wasm.setValue(dimsOffset + index * ptrSize, d, ptrSize === 4 ? 'i32' : 'i64'));\n    const tensor = wasm._OrtCreateTensor(\n      tensorDataTypeStringToEnum(dataType),\n      rawData,\n      dataByteLength,\n      dimsOffset,\n      dims.length,\n      dataLocationStringToEnum(actualLocation),\n    );\n    if (tensor === 0) {\n      checkLastError(`Can't create tensor for input/output. session=${sessionId}, index=${index}.`);\n    }\n    tensorHandles.push(tensor);\n  } finally {\n    wasm.stackRestore(stack);\n  }\n};\n\n/**\n * perform inference run\n */\nexport const run = async (\n  sessionId: number,\n  inputIndices: number[],\n  inputTensors: TensorMetadata[],\n  outputIndices: number[],\n  outputTensors: Array<TensorMetadata | null>,\n  options: InferenceSession.RunOptions,\n): Promise<TensorMetadata[]> => {\n  const wasm = getInstance();\n  const ptrSize = wasm.PTR_SIZE;\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error(`cannot run inference. invalid session id: ${sessionId}`);\n  }\n  const sessionHandle = session[0];\n  const inputNamesUTF8Encoded = session[1];\n  const outputNamesUTF8Encoded = session[2];\n  const ioBindingState = session[3];\n  const enableGraphCapture = session[4];\n  const inputOutputBound = session[5];\n\n  const inputCount = inputIndices.length;\n  const outputCount = outputIndices.length;\n\n  let runOptionsHandle = 0;\n  let runOptionsAllocs: number[] = [];\n\n  const inputTensorHandles: number[] = [];\n  const outputTensorHandles: number[] = [];\n  const inputOutputAllocs: number[] = [];\n  const preAllocatedOutputs: number[] = [];\n\n  const beforeRunStack = wasm.stackSave();\n  const inputValuesOffset = wasm.stackAlloc(inputCount * ptrSize);\n  const inputNamesOffset = wasm.stackAlloc(inputCount * ptrSize);\n  const outputValuesOffset = wasm.stackAlloc(outputCount * ptrSize);\n  const outputNamesOffset = wasm.stackAlloc(outputCount * ptrSize);\n\n  try {\n    [runOptionsHandle, runOptionsAllocs] = setRunOptions(options);\n\n    TRACE_EVENT_BEGIN('wasm prepareInputOutputTensor');\n    // create input tensors\n    for (let i = 0; i < inputCount; i++) {\n      await prepareInputOutputTensor(\n        inputTensors[i],\n        inputTensorHandles,\n        inputOutputAllocs,\n        sessionId,\n        inputNamesUTF8Encoded[inputIndices[i]],\n        inputIndices[i],\n        enableGraphCapture,\n      );\n    }\n\n    // create output tensors\n    for (let i = 0; i < outputCount; i++) {\n      await prepareInputOutputTensor(\n        outputTensors[i],\n        outputTensorHandles,\n        inputOutputAllocs,\n        sessionId,\n        outputNamesUTF8Encoded[outputIndices[i]],\n        inputCount + outputIndices[i],\n        enableGraphCapture,\n      );\n    }\n    TRACE_EVENT_END('wasm prepareInputOutputTensor');\n\n    for (let i = 0; i < inputCount; i++) {\n      wasm.setValue(inputValuesOffset + i * ptrSize, inputTensorHandles[i], '*');\n      wasm.setValue(inputNamesOffset + i * ptrSize, inputNamesUTF8Encoded[inputIndices[i]], '*');\n    }\n    for (let i = 0; i < outputCount; i++) {\n      wasm.setValue(outputValuesOffset + i * ptrSize, outputTensorHandles[i], '*');\n      wasm.setValue(outputNamesOffset + i * ptrSize, outputNamesUTF8Encoded[outputIndices[i]], '*');\n    }\n\n    if ((!BUILD_DEFS.DISABLE_JSEP || !BUILD_DEFS.DISABLE_WEBGPU) && ioBindingState && !inputOutputBound) {\n      const { handle, outputPreferredLocations, outputPreferredLocationsEncoded } = ioBindingState;\n\n      if (inputNamesUTF8Encoded.length !== inputCount) {\n        throw new Error(\n          `input count from feeds (${inputCount}) is expected to be always equal to model's input count (${inputNamesUTF8Encoded.length}).`,\n        );\n      }\n\n      TRACE_EVENT_BEGIN('wasm bindInputsOutputs');\n      // process inputs\n      for (let i = 0; i < inputCount; i++) {\n        const index = inputIndices[i];\n        const errorCode = await wasm._OrtBindInput(handle, inputNamesUTF8Encoded[index], inputTensorHandles[i]);\n        if (errorCode !== 0) {\n          checkLastError(`Can't bind input[${i}] for session=${sessionId}.`);\n        }\n      }\n\n      // process pre-allocated outputs\n      for (let i = 0; i < outputCount; i++) {\n        const index = outputIndices[i];\n        const location = outputTensors[i]?.[3]; // undefined means output is not pre-allocated.\n\n        if (location) {\n          // output is pre-allocated, store and bind the tensor.\n          preAllocatedOutputs.push(outputTensorHandles[i]);\n          const errorCode = wasm._OrtBindOutput(handle, outputNamesUTF8Encoded[index], outputTensorHandles[i], 0);\n          if (errorCode !== 0) {\n            checkLastError(`Can't bind pre-allocated output[${i}] for session=${sessionId}.`);\n          }\n        } else {\n          // output is not pre-allocated. reset preferred location.\n          const errorCode = wasm._OrtBindOutput(\n            handle,\n            outputNamesUTF8Encoded[index],\n            0,\n            outputPreferredLocationsEncoded[index],\n          );\n          if (errorCode !== 0) {\n            checkLastError(`Can't bind output[${i}] to ${outputPreferredLocations[i]} for session=${sessionId}.`);\n          }\n        }\n      }\n      TRACE_EVENT_END('wasm bindInputsOutputs');\n      activeSessions.set(sessionId, [\n        sessionHandle,\n        inputNamesUTF8Encoded,\n        outputNamesUTF8Encoded,\n        ioBindingState,\n        enableGraphCapture,\n        true,\n      ]);\n    }\n\n    wasm.jsepOnRunStart?.(sessionHandle);\n    wasm.webnnOnRunStart?.(sessionHandle);\n\n    let errorCode: number;\n    if ((!BUILD_DEFS.DISABLE_JSEP || !BUILD_DEFS.DISABLE_WEBGPU) && ioBindingState) {\n      errorCode = await wasm._OrtRunWithBinding(\n        sessionHandle,\n        ioBindingState.handle,\n        outputCount,\n        outputValuesOffset,\n        runOptionsHandle,\n      );\n    } else {\n      errorCode = await wasm._OrtRun(\n        sessionHandle,\n        inputNamesOffset,\n        inputValuesOffset,\n        inputCount,\n        outputNamesOffset,\n        outputCount,\n        outputValuesOffset,\n        runOptionsHandle,\n      );\n    }\n\n    if (errorCode !== 0) {\n      checkLastError('failed to call OrtRun().');\n    }\n\n    const output: TensorMetadata[] = [];\n    const outputPromises: Array<Promise<[number, Tensor.DataType]>> = [];\n\n    TRACE_EVENT_BEGIN('wasm ProcessOutputTensor');\n    for (let i = 0; i < outputCount; i++) {\n      const tensor = Number(wasm.getValue(outputValuesOffset + i * ptrSize, '*'));\n      // TODO: revisit this part to ensure it works for WebGPU when both pre-allocated outputs and\n      // preferred location are specified.\n      // Certain pre-allocated tensors may already be bound in the IO binding. e.g. the WebNN backend\n      // always binds its tensor to 'ml-tensor'. In such cases, the tensor ID might change after binding,\n      // but copying data for these tensors should still be avoided.\n      if (tensor === outputTensorHandles[i] || preAllocatedOutputs.includes(outputTensorHandles[i])) {\n        // output tensor is pre-allocated. no need to copy data.\n        output.push(outputTensors[i]!);\n        if (tensor !== outputTensorHandles[i]) {\n          // release redundant tensor earlier.\n          if (wasm._OrtReleaseTensor(tensor) !== 0) {\n            checkLastError(\"Can't release tensor.\");\n          }\n        }\n        continue;\n      }\n\n      const beforeGetTensorDataStack = wasm.stackSave();\n      // stack allocate 4 pointer value\n      const tensorDataOffset = wasm.stackAlloc(4 * ptrSize);\n\n      let keepOutputTensor = false;\n      let type: Tensor.Type | undefined,\n        dataOffset = 0;\n      try {\n        const errorCode = wasm._OrtGetTensorData(\n          tensor,\n          tensorDataOffset,\n          tensorDataOffset + ptrSize,\n          tensorDataOffset + 2 * ptrSize,\n\n          tensorDataOffset + 3 * ptrSize,\n        );\n        if (errorCode !== 0) {\n          checkLastError(`Can't access output tensor data on index ${i}.`);\n        }\n        const valueType = ptrSize === 4 ? 'i32' : 'i64';\n        const dataType = Number(wasm.getValue(tensorDataOffset, valueType));\n        dataOffset = wasm.getValue(tensorDataOffset + ptrSize, '*');\n        const dimsOffset = wasm.getValue(tensorDataOffset + ptrSize * 2, '*');\n        const dimsLength = Number(wasm.getValue(tensorDataOffset + ptrSize * 3, valueType));\n        const dims = [];\n        for (let i = 0; i < dimsLength; i++) {\n          dims.push(Number(wasm.getValue(dimsOffset + i * ptrSize, valueType)));\n        }\n        if (wasm._OrtFree(dimsOffset) !== 0) {\n          checkLastError(\"Can't free memory for tensor dims.\");\n        }\n        const size = dims.reduce((a, b) => a * b, 1);\n        type = tensorDataTypeEnumToString(dataType);\n\n        const preferredLocation = ioBindingState?.outputPreferredLocations[outputIndices[i]];\n\n        if (type === 'string') {\n          if (preferredLocation === 'gpu-buffer' || preferredLocation === 'ml-tensor') {\n            throw new Error('String tensor is not supported on GPU.');\n          }\n          const stringData: string[] = [];\n          for (let i = 0; i < size; i++) {\n            const offset = wasm.getValue(dataOffset + i * ptrSize, '*');\n            const nextOffset = wasm.getValue(dataOffset + (i + 1) * ptrSize, '*');\n            const maxBytesToRead = i === size - 1 ? undefined : nextOffset - offset;\n            stringData.push(wasm.UTF8ToString(offset, maxBytesToRead));\n          }\n          output.push([type, dims, stringData, 'cpu']);\n        } else {\n          // If a certain output's preferred location is GPU but the tensor is empty, we still need to create a CPU\n          // tensor for it. There is no mapping GPU buffer for an empty tensor.\n          if (preferredLocation === 'gpu-buffer' && size > 0) {\n            const getBuffer = !BUILD_DEFS.DISABLE_WEBGPU ? wasm.webgpuGetBuffer : wasm.jsepGetBuffer;\n            if (!getBuffer) {\n              throw new Error('preferredLocation \"gpu-buffer\" is not supported without using WebGPU.');\n            }\n            const gpuBuffer = getBuffer(dataOffset);\n            const bufferSize = calculateTensorSizeInBytes(dataType, size);\n            if (bufferSize === undefined || !isGpuBufferSupportedType(type)) {\n              throw new Error(`Unsupported data type: ${type}`);\n            }\n\n            // do not release the tensor right now. it will be released when user calls tensor.dispose().\n            keepOutputTensor = true;\n\n            if (!BUILD_DEFS.DISABLE_WEBGPU) {\n              wasm.webgpuRegisterBuffer!(gpuBuffer, sessionId, dataOffset);\n              const downloadDataFunction = wasm.webgpuCreateDownloader!(gpuBuffer, bufferSize, sessionId);\n              output.push([\n                type,\n                dims,\n                {\n                  gpuBuffer,\n                  download: async () => {\n                    const arrayBuffer = await downloadDataFunction();\n                    const data = new (tensorTypeToTypedArrayConstructor(type!))(arrayBuffer);\n                    return data as Tensor.DataTypeMap[Tensor.GpuBufferDataTypes];\n                  },\n                  dispose: () => {\n                    if (wasm._OrtReleaseTensor(tensor) !== 0) {\n                      checkLastError(\"Can't release tensor.\");\n                    }\n                  },\n                },\n                'gpu-buffer',\n              ]);\n            } else {\n              output.push([\n                type,\n                dims,\n                {\n                  gpuBuffer,\n                  download: wasm.jsepCreateDownloader!(gpuBuffer, bufferSize, type),\n                  dispose: () => {\n                    if (wasm._OrtReleaseTensor(tensor) !== 0) {\n                      checkLastError(\"Can't release tensor.\");\n                    }\n                  },\n                },\n                'gpu-buffer',\n              ]);\n            }\n          } else if (preferredLocation === 'ml-tensor' && size > 0) {\n            const ensureTensor = wasm.webnnEnsureTensor;\n            const isGraphInputOutputTypeSupported = wasm.webnnIsGraphInputOutputTypeSupported;\n            if (!ensureTensor || !isGraphInputOutputTypeSupported) {\n              throw new Error('preferredLocation \"ml-tensor\" is not supported without using WebNN.');\n            }\n            const tensorSize = calculateTensorSizeInBytes(dataType, size);\n            if (tensorSize === undefined || !isMLTensorSupportedType(type)) {\n              throw new Error(`Unsupported data type: ${type}`);\n            }\n            if (!isGraphInputOutputTypeSupported(sessionId, type, false)) {\n              throw new Error(\n                `preferredLocation \"ml-tensor\" for ${type} output is not supported by current WebNN Context.`,\n              );\n            }\n\n            // If the graph has been partitioned, the output tensor may have not been created. For this reason, we use\n            // ensureTensor to get/create the MLTensor. In which case, we don't need to copy the data if a new tensor\n            // has been created.\n            const mlTensor = await ensureTensor(sessionId, dataOffset, dataType, dims, false);\n\n            // do not release the tensor right now. it will be released when user calls tensor.dispose().\n            keepOutputTensor = true;\n\n            output.push([\n              type,\n              dims,\n              {\n                mlTensor,\n                download: wasm.webnnCreateMLTensorDownloader!(dataOffset, type),\n                dispose: () => {\n                  wasm.webnnReleaseTensorId!(dataOffset);\n                  wasm._OrtReleaseTensor(tensor);\n                },\n              },\n              'ml-tensor',\n            ]);\n          } else if (preferredLocation === 'ml-tensor-cpu-output' && size > 0) {\n            const data = wasm.webnnCreateMLTensorDownloader!(dataOffset, type as Tensor.MLTensorDataTypes)();\n            const index = output.length;\n            // Delay the data download and releasing the tensor until we can wait for all output tensors to be downloaded.\n            keepOutputTensor = true;\n            outputPromises.push(\n              (async () => {\n                const result: [number, Tensor.DataType] = [index, await data];\n                wasm.webnnReleaseTensorId!(dataOffset);\n                wasm._OrtReleaseTensor(tensor);\n                return result;\n              })(),\n            );\n            output.push([type, dims, [], 'cpu']);\n          } else {\n            const typedArrayConstructor = tensorTypeToTypedArrayConstructor(type);\n            const data = new typedArrayConstructor(size);\n            new Uint8Array(data.buffer, data.byteOffset, data.byteLength).set(\n              wasm.HEAPU8.subarray(dataOffset, dataOffset + data.byteLength),\n            );\n            output.push([type, dims, data, 'cpu']);\n          }\n        }\n      } finally {\n        wasm.stackRestore(beforeGetTensorDataStack);\n        if (type === 'string' && dataOffset) {\n          wasm._free(dataOffset);\n        }\n        if (!keepOutputTensor) {\n          wasm._OrtReleaseTensor(tensor);\n        }\n      }\n    }\n\n    if (ioBindingState && !enableGraphCapture) {\n      if (wasm._OrtClearBoundOutputs(ioBindingState.handle) !== 0) {\n        checkLastError(\"Can't clear bound outputs.\");\n      }\n      activeSessions.set(sessionId, [\n        sessionHandle,\n        inputNamesUTF8Encoded,\n        outputNamesUTF8Encoded,\n        ioBindingState,\n        enableGraphCapture,\n        false,\n      ]);\n    }\n    // Wait for all output tensor data to be downloaded.\n    for (const [index, data] of await Promise.all(outputPromises)) {\n      output[index][2] = data;\n    }\n    TRACE_EVENT_END('wasm ProcessOutputTensor');\n    return output;\n  } finally {\n    wasm.webnnOnRunEnd?.(sessionHandle);\n\n    wasm.stackRestore(beforeRunStack);\n\n    if (!BUILD_DEFS.DISABLE_WEBGPU) {\n      inputTensors.forEach((t) => {\n        if (t && t[3] === 'gpu-buffer') {\n          wasm.webgpuUnregisterBuffer!(t[2].gpuBuffer);\n        }\n      });\n      outputTensors.forEach((t) => {\n        if (t && t[3] === 'gpu-buffer') {\n          wasm.webgpuUnregisterBuffer!(t[2].gpuBuffer);\n        }\n      });\n    }\n    inputTensorHandles.forEach((v) => wasm._OrtReleaseTensor(v));\n    outputTensorHandles.forEach((v) => wasm._OrtReleaseTensor(v));\n    inputOutputAllocs.forEach((p) => wasm._free(p));\n\n    if (runOptionsHandle !== 0) {\n      wasm._OrtReleaseRunOptions(runOptionsHandle);\n    }\n    runOptionsAllocs.forEach((p) => wasm._free(p));\n  }\n};\n\n/**\n * end profiling\n */\nexport const endProfiling = (sessionId: number): void => {\n  const wasm = getInstance();\n  const session = activeSessions.get(sessionId);\n  if (!session) {\n    throw new Error('invalid session id');\n  }\n  const sessionHandle = session[0];\n\n  // profile file name is not used yet, but it must be freed.\n  const profileFileName = wasm._OrtEndProfiling(sessionHandle);\n  if (profileFileName === 0) {\n    checkLastError(\"Can't get an profile file name.\");\n  }\n  wasm._OrtFree(profileFileName);\n};\n\nexport const extractTransferableBuffers = (tensors: readonly SerializableTensorMetadata[]): ArrayBufferLike[] => {\n  const buffers: ArrayBufferLike[] = [];\n  for (const tensor of tensors) {\n    const data = tensor[2];\n    if (!Array.isArray(data) && 'buffer' in data) {\n      buffers.push(data.buffer);\n    }\n  }\n  return buffers;\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { env, InferenceSession } from 'onnxruntime-common';\n\nimport {\n  OrtWasmMessage,\n  SerializableInternalBuffer,\n  SerializableSessionMetadata,\n  SerializableTensorMetadata,\n  TensorMetadata,\n} from './proxy-messages';\nimport * as core from './wasm-core-impl';\nimport { initializeWebAssembly } from './wasm-factory';\nimport {\n  importProxyWorker,\n  inferWasmPathPrefixFromScriptSrc,\n  isEsmImportMetaUrlHardcodedAsFileUri,\n} from './wasm-utils-import';\n\nconst isProxy = (): boolean => !!env.wasm.proxy && typeof document !== 'undefined';\nlet proxyWorker: Worker | undefined;\nlet initializing = false;\nlet initialized = false;\nlet aborted = false;\nlet temporaryObjectUrl: string | undefined;\n\ntype PromiseCallbacks<T = void> = [resolve: (result: T) => void, reject: (reason: unknown) => void];\nlet initWasmCallbacks: PromiseCallbacks;\nconst queuedCallbacks: Map<OrtWasmMessage['type'], Array<PromiseCallbacks<unknown>>> = new Map();\n\nconst enqueueCallbacks = (type: OrtWasmMessage['type'], callbacks: PromiseCallbacks<unknown>): void => {\n  const queue = queuedCallbacks.get(type);\n  if (queue) {\n    queue.push(callbacks);\n  } else {\n    queuedCallbacks.set(type, [callbacks]);\n  }\n};\n\nconst ensureWorker = (): void => {\n  if (initializing || !initialized || aborted || !proxyWorker) {\n    throw new Error('worker not ready');\n  }\n};\n\nconst onProxyWorkerMessage = (ev: MessageEvent<OrtWasmMessage>): void => {\n  switch (ev.data.type) {\n    case 'init-wasm':\n      initializing = false;\n      if (ev.data.err) {\n        aborted = true;\n        initWasmCallbacks[1](ev.data.err);\n      } else {\n        initialized = true;\n        initWasmCallbacks[0]();\n      }\n      if (temporaryObjectUrl) {\n        URL.revokeObjectURL(temporaryObjectUrl);\n        temporaryObjectUrl = undefined;\n      }\n      break;\n    case 'init-ep':\n    case 'copy-from':\n    case 'create':\n    case 'release':\n    case 'run':\n    case 'end-profiling': {\n      const callbacks = queuedCallbacks.get(ev.data.type)!;\n      if (ev.data.err) {\n        callbacks.shift()![1](ev.data.err);\n      } else {\n        callbacks.shift()![0](ev.data.out!);\n      }\n      break;\n    }\n    default:\n  }\n};\n\nexport const initializeWebAssemblyAndOrtRuntime = async (): Promise<void> => {\n  if (initialized) {\n    return;\n  }\n  if (initializing) {\n    throw new Error(\"multiple calls to 'initWasm()' detected.\");\n  }\n  if (aborted) {\n    throw new Error(\"previous call to 'initWasm()' failed.\");\n  }\n\n  initializing = true;\n\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    return new Promise<void>((resolve, reject) => {\n      proxyWorker?.terminate();\n\n      void importProxyWorker().then(([objectUrl, worker]) => {\n        try {\n          proxyWorker = worker;\n          proxyWorker.onerror = (ev: ErrorEvent) => reject(ev);\n          proxyWorker.onmessage = onProxyWorkerMessage;\n          initWasmCallbacks = [resolve, reject];\n          const message: OrtWasmMessage = { type: 'init-wasm', in: env };\n\n          // if the proxy worker is loaded from a blob URL, we need to make sure the path information is not lost.\n          //\n          // when `env.wasm.wasmPaths` is not set, we need to pass the path information to the worker.\n          //\n          if (!BUILD_DEFS.ENABLE_BUNDLE_WASM_JS && !message.in!.wasm.wasmPaths && objectUrl) {\n            // for a build not bundled the wasm JS, we need to pass the path prefix to the worker.\n            // the path prefix will be used to resolve the path to both the wasm JS and the wasm file.\n            const inferredWasmPathPrefix = inferWasmPathPrefixFromScriptSrc();\n            if (inferredWasmPathPrefix) {\n              message.in!.wasm.wasmPaths = inferredWasmPathPrefix;\n            }\n          }\n\n          if (\n            BUILD_DEFS.IS_ESM &&\n            BUILD_DEFS.ENABLE_BUNDLE_WASM_JS &&\n            !message.in!.wasm.wasmPaths &&\n            (objectUrl || isEsmImportMetaUrlHardcodedAsFileUri)\n          ) {\n            // for a build bundled the wasm JS, if either of the following conditions is met:\n            // - the proxy worker is loaded from a blob URL\n            // - `import.meta.url` is a file URL, it means it is overwritten by the bundler.\n            //\n            // in either case, the path information is lost, we need to pass the path of the .wasm file to the worker.\n            // we need to use the bundler preferred URL format:\n            // new URL('filename', import.meta.url)\n            // so that the bundler can handle the file using corresponding loaders.\n            message.in!.wasm.wasmPaths = {\n              wasm: !BUILD_DEFS.DISABLE_JSEP\n                ? new URL('ort-wasm-simd-threaded.jsep.wasm', BUILD_DEFS.ESM_IMPORT_META_URL).href\n                : BUILD_DEFS.ENABLE_JSPI\n                  ? new URL('ort-wasm-simd-threaded.jspi.wasm', BUILD_DEFS.ESM_IMPORT_META_URL).href\n                  : !BUILD_DEFS.DISABLE_WEBGPU\n                    ? new URL('ort-wasm-simd-threaded.asyncify.wasm', BUILD_DEFS.ESM_IMPORT_META_URL).href\n                    : new URL('ort-wasm-simd-threaded.wasm', BUILD_DEFS.ESM_IMPORT_META_URL).href,\n            };\n          }\n          proxyWorker.postMessage(message);\n          temporaryObjectUrl = objectUrl;\n        } catch (e) {\n          reject(e);\n        }\n      }, reject);\n    });\n  } else {\n    try {\n      await initializeWebAssembly(env.wasm);\n      await core.initRuntime(env);\n      initialized = true;\n    } catch (e) {\n      aborted = true;\n      throw e;\n    } finally {\n      initializing = false;\n    }\n  }\n};\n\nexport const initializeOrtEp = async (epName: string): Promise<void> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    ensureWorker();\n    return new Promise<void>((resolve, reject) => {\n      enqueueCallbacks('init-ep', [resolve, reject]);\n      const message: OrtWasmMessage = { type: 'init-ep', in: { epName, env } };\n      proxyWorker!.postMessage(message);\n    });\n  } else {\n    await core.initEp(env, epName);\n  }\n};\n\nexport const copyFromExternalBuffer = async (buffer: Uint8Array): Promise<SerializableInternalBuffer> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    ensureWorker();\n    return new Promise<SerializableInternalBuffer>((resolve, reject) => {\n      enqueueCallbacks('copy-from', [resolve, reject]);\n      const message: OrtWasmMessage = { type: 'copy-from', in: { buffer } };\n      proxyWorker!.postMessage(message, [buffer.buffer]);\n    });\n  } else {\n    return core.copyFromExternalBuffer(buffer);\n  }\n};\n\nexport const createSession = async (\n  model: SerializableInternalBuffer | Uint8Array,\n  options?: InferenceSession.SessionOptions,\n): Promise<SerializableSessionMetadata> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    // check unsupported options\n    if (options?.preferredOutputLocation) {\n      throw new Error('session option \"preferredOutputLocation\" is not supported for proxy.');\n    }\n    ensureWorker();\n    return new Promise<SerializableSessionMetadata>((resolve, reject) => {\n      enqueueCallbacks('create', [resolve, reject]);\n      const message: OrtWasmMessage = { type: 'create', in: { model, options: { ...options } } };\n      const transferable: Transferable[] = [];\n      if (model instanceof Uint8Array) {\n        transferable.push(model.buffer);\n      }\n      proxyWorker!.postMessage(message, transferable);\n    });\n  } else {\n    return core.createSession(model, options);\n  }\n};\n\nexport const releaseSession = async (sessionId: number): Promise<void> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    ensureWorker();\n    return new Promise<void>((resolve, reject) => {\n      enqueueCallbacks('release', [resolve, reject]);\n      const message: OrtWasmMessage = { type: 'release', in: sessionId };\n      proxyWorker!.postMessage(message);\n    });\n  } else {\n    core.releaseSession(sessionId);\n  }\n};\n\nexport const run = async (\n  sessionId: number,\n  inputIndices: number[],\n  inputs: TensorMetadata[],\n  outputIndices: number[],\n  outputs: Array<TensorMetadata | null>,\n  options: InferenceSession.RunOptions,\n): Promise<TensorMetadata[]> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    // check inputs location\n    if (inputs.some((t) => t[3] !== 'cpu')) {\n      throw new Error('input tensor on GPU is not supported for proxy.');\n    }\n    // check outputs location\n    if (outputs.some((t) => t)) {\n      throw new Error('pre-allocated output tensor is not supported for proxy.');\n    }\n    ensureWorker();\n    return new Promise<SerializableTensorMetadata[]>((resolve, reject) => {\n      enqueueCallbacks('run', [resolve, reject]);\n      const serializableInputs = inputs as SerializableTensorMetadata[]; // every input is on CPU.\n      const message: OrtWasmMessage = {\n        type: 'run',\n        in: { sessionId, inputIndices, inputs: serializableInputs, outputIndices, options },\n      };\n      proxyWorker!.postMessage(message, core.extractTransferableBuffers(serializableInputs));\n    });\n  } else {\n    return core.run(sessionId, inputIndices, inputs, outputIndices, outputs, options);\n  }\n};\n\nexport const endProfiling = async (sessionId: number): Promise<void> => {\n  if (!BUILD_DEFS.DISABLE_WASM_PROXY && isProxy()) {\n    ensureWorker();\n    return new Promise<void>((resolve, reject) => {\n      enqueueCallbacks('end-profiling', [resolve, reject]);\n      const message: OrtWasmMessage = { type: 'end-profiling', in: sessionId };\n      proxyWorker!.postMessage(message);\n    });\n  } else {\n    core.endProfiling(sessionId);\n  }\n};\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport {\n  InferenceSession,\n  InferenceSessionHandler,\n  SessionHandler,\n  Tensor,\n  TRACE_FUNC_BEGIN,\n  TRACE_FUNC_END,\n} from 'onnxruntime-common';\n\nimport { SerializableInternalBuffer, TensorMetadata } from './proxy-messages';\nimport { copyFromExternalBuffer, createSession, endProfiling, releaseSession, run } from './proxy-wrapper';\nimport { isGpuBufferSupportedType, isMLTensorSupportedType } from './wasm-common';\nimport { isNode } from './wasm-utils-env';\nimport { loadFile } from './wasm-utils-load-file';\n\nexport const encodeTensorMetadata = (tensor: Tensor, getName: () => string): TensorMetadata => {\n  switch (tensor.location) {\n    case 'cpu':\n      return [tensor.type, tensor.dims, tensor.data, 'cpu'];\n    case 'gpu-buffer':\n      return [tensor.type, tensor.dims, { gpuBuffer: tensor.gpuBuffer }, 'gpu-buffer'];\n    case 'ml-tensor':\n      return [tensor.type, tensor.dims, { mlTensor: tensor.mlTensor }, 'ml-tensor'];\n    default:\n      throw new Error(`invalid data location: ${tensor.location} for ${getName()}`);\n  }\n};\n\nexport const decodeTensorMetadata = (tensor: TensorMetadata): Tensor => {\n  switch (tensor[3]) {\n    case 'cpu':\n      return new Tensor(tensor[0], tensor[2], tensor[1]);\n    case 'gpu-buffer': {\n      const dataType = tensor[0];\n      if (!isGpuBufferSupportedType(dataType)) {\n        throw new Error(`not supported data type: ${dataType} for deserializing GPU tensor`);\n      }\n      const { gpuBuffer, download, dispose } = tensor[2];\n      return Tensor.fromGpuBuffer(gpuBuffer, { dataType, dims: tensor[1], download, dispose });\n    }\n    case 'ml-tensor': {\n      const dataType = tensor[0];\n      if (!isMLTensorSupportedType(dataType)) {\n        throw new Error(`not supported data type: ${dataType} for deserializing MLTensor tensor`);\n      }\n      const { mlTensor, download, dispose } = tensor[2];\n      return Tensor.fromMLTensor(mlTensor, { dataType, dims: tensor[1], download, dispose });\n    }\n    default:\n      throw new Error(`invalid data location: ${tensor[3]}`);\n  }\n};\n\nexport class OnnxruntimeWebAssemblySessionHandler implements InferenceSessionHandler {\n  private sessionId: number;\n\n  inputNames: readonly string[];\n  outputNames: readonly string[];\n  inputMetadata: readonly InferenceSession.ValueMetadata[];\n  outputMetadata: readonly InferenceSession.ValueMetadata[];\n\n  async fetchModelAndCopyToWasmMemory(path: string): Promise<SerializableInternalBuffer> {\n    // fetch model from url and move to wasm heap.\n    return copyFromExternalBuffer(await loadFile(path));\n  }\n\n  async loadModel(pathOrBuffer: string | Uint8Array, options?: InferenceSession.SessionOptions): Promise<void> {\n    TRACE_FUNC_BEGIN();\n    let model: Parameters<typeof createSession>[0];\n\n    if (typeof pathOrBuffer === 'string') {\n      if (isNode) {\n        // node\n        model = await loadFile(pathOrBuffer);\n      } else {\n        // browser\n        // fetch model and copy to wasm heap.\n        model = await this.fetchModelAndCopyToWasmMemory(pathOrBuffer);\n      }\n    } else {\n      model = pathOrBuffer;\n    }\n\n    [this.sessionId, this.inputNames, this.outputNames, this.inputMetadata, this.outputMetadata] = await createSession(\n      model,\n      options,\n    );\n    TRACE_FUNC_END();\n  }\n\n  async dispose(): Promise<void> {\n    return releaseSession(this.sessionId);\n  }\n\n  async run(\n    feeds: SessionHandler.FeedsType,\n    fetches: SessionHandler.FetchesType,\n    options: InferenceSession.RunOptions,\n  ): Promise<SessionHandler.ReturnType> {\n    TRACE_FUNC_BEGIN();\n    const inputArray: Tensor[] = [];\n    const inputIndices: number[] = [];\n    Object.entries(feeds).forEach((kvp) => {\n      const name = kvp[0];\n      const tensor = kvp[1];\n      const index = this.inputNames.indexOf(name);\n      if (index === -1) {\n        throw new Error(`invalid input '${name}'`);\n      }\n      inputArray.push(tensor);\n      inputIndices.push(index);\n    });\n\n    const outputArray: Array<Tensor | null> = [];\n    const outputIndices: number[] = [];\n    Object.entries(fetches).forEach((kvp) => {\n      const name = kvp[0];\n      const tensor = kvp[1];\n      const index = this.outputNames.indexOf(name);\n      if (index === -1) {\n        throw new Error(`invalid output '${name}'`);\n      }\n      outputArray.push(tensor);\n      outputIndices.push(index);\n    });\n\n    const inputs = inputArray.map((t, i) =>\n      encodeTensorMetadata(t, () => `input \"${this.inputNames[inputIndices[i]]}\"`),\n    );\n    const outputs = outputArray.map((t, i) =>\n      t ? encodeTensorMetadata(t, () => `output \"${this.outputNames[outputIndices[i]]}\"`) : null,\n    );\n\n    const results = await run(this.sessionId, inputIndices, inputs, outputIndices, outputs, options);\n\n    const resultMap: SessionHandler.ReturnType = {};\n    for (let i = 0; i < results.length; i++) {\n      resultMap[this.outputNames[outputIndices[i]]] = outputArray[i] ?? decodeTensorMetadata(results[i]);\n    }\n    TRACE_FUNC_END();\n    return resultMap;\n  }\n\n  startProfiling(): void {\n    // TODO: implement profiling\n  }\n\n  endProfiling(): void {\n    void endProfiling(this.sessionId);\n  }\n}\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\nimport { Backend, env, InferenceSession, InferenceSessionHandler } from 'onnxruntime-common';\n\nimport { initializeOrtEp, initializeWebAssemblyAndOrtRuntime } from './wasm/proxy-wrapper';\nimport { OnnxruntimeWebAssemblySessionHandler } from './wasm/session-handler-inference';\n\n/**\n * This function initializes all flags for WebAssembly.\n *\n * Those flags are accessible from `ort.env.wasm`. Users are allow to set those flags before the first inference session\n * being created, to override default value.\n */\nexport const initializeFlags = (): void => {\n  if (typeof env.wasm.initTimeout !== 'number' || env.wasm.initTimeout < 0) {\n    env.wasm.initTimeout = 0;\n  }\n\n  const simd = env.wasm.simd;\n  if (typeof simd !== 'boolean' && simd !== undefined && simd !== 'fixed' && simd !== 'relaxed') {\n    // eslint-disable-next-line no-console\n    console.warn(\n      `Property \"env.wasm.simd\" is set to unknown value \"${simd}\". Reset it to \\`false\\` and ignore SIMD feature checking.`,\n    );\n    env.wasm.simd = false;\n  }\n\n  if (typeof env.wasm.proxy !== 'boolean') {\n    env.wasm.proxy = false;\n  }\n\n  if (typeof env.wasm.trace !== 'boolean') {\n    env.wasm.trace = false;\n  }\n\n  if (typeof env.wasm.numThreads !== 'number' || !Number.isInteger(env.wasm.numThreads) || env.wasm.numThreads <= 0) {\n    // The following logic only applies when `ort.env.wasm.numThreads` is not set by user. We will always honor user's\n    // setting if it is provided.\n\n    // Browser: when crossOriginIsolated is false, SharedArrayBuffer is not available so WebAssembly threads will not\n    // work. In this case, we will set numThreads to 1.\n    //\n    // There is an exception: when the browser is configured to force-enable SharedArrayBuffer (e.g. Chromuim with\n    // --enable-features=SharedArrayBuffer), it is possible that `self.crossOriginIsolated` is false and\n    // SharedArrayBuffer is available at the same time. This is usually for testing. In this case,  we will still set\n    // numThreads to 1 here. If we want to enable multi-threading in test, we should set `ort.env.wasm.numThreads` to a\n    // value greater than 1.\n    if (typeof self !== 'undefined' && !self.crossOriginIsolated) {\n      env.wasm.numThreads = 1;\n    } else {\n      const numCpuLogicalCores =\n        typeof navigator === 'undefined' ? require('node:os').cpus().length : navigator.hardwareConcurrency;\n      env.wasm.numThreads = Math.min(4, Math.ceil((numCpuLogicalCores || 1) / 2));\n    }\n  }\n};\n\nexport class OnnxruntimeWebAssemblyBackend implements Backend {\n  /**\n   * This function initializes the WebAssembly backend.\n   *\n   * This function will be called only once for each backend name. It will be called the first time when\n   * `ort.InferenceSession.create()` is called with a registered backend name.\n   *\n   * @param backendName - the registered backend name.\n   */\n  async init(backendName: string): Promise<void> {\n    // populate wasm flags\n    initializeFlags();\n\n    // init wasm\n    await initializeWebAssemblyAndOrtRuntime();\n\n    // performe EP specific initialization\n    await initializeOrtEp(backendName);\n  }\n  createInferenceSessionHandler(\n    path: string,\n    options?: InferenceSession.SessionOptions,\n  ): Promise<InferenceSessionHandler>;\n  createInferenceSessionHandler(\n    buffer: Uint8Array,\n    options?: InferenceSession.SessionOptions,\n  ): Promise<InferenceSessionHandler>;\n  async createInferenceSessionHandler(\n    pathOrBuffer: string | Uint8Array,\n    options?: InferenceSession.SessionOptions,\n  ): Promise<InferenceSessionHandler> {\n    const handler = new OnnxruntimeWebAssemblySessionHandler();\n    await handler.loadModel(pathOrBuffer, options);\n    return handler;\n  }\n}\n\nexport const wasmBackend = new OnnxruntimeWebAssemblyBackend();\n", "// Copyright (c) Microsoft Corporation. All rights reserved.\n// Licensed under the MIT License.\n\n/* eslint-disable @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports */\n\n// We use \"require\" instead of \"import\" here because import statement must be put in top level. Our current code does\n// not allow bundler to tree-shaking code as expected because some codes are treated as having side effects.\n// So we import code inside the if-clause to allow bundler remove the code safely.\n\nexport * from 'onnxruntime-common';\nimport * as ort from 'onnxruntime-common';\nexport default ort;\n\nimport { registerBackend, env } from 'onnxruntime-common';\nimport { version } from './version';\n\nif (!BUILD_DEFS.DISABLE_WEBGL) {\n  const onnxjsBackend = require('./backend-onnxjs').onnxjsBackend;\n  registerBackend('webgl', onnxjsBackend, -10);\n}\n\nif (!BUILD_DEFS.DISABLE_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.26.0';\n"],
  "mappings": "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",
  "names": ["i", "env", "Float16Array", "Tensor", "Tensor", "InferenceSession", "InferenceSession", "Tensor", "env", "env", "wasm", "wasm", "wasm", "location", "pad", "tensor", "env", "mlContextIndex", "wasm", "init", "offsets", "indices", "impl", "validateInputs", "reduceOps", "validateInputs", "validateInputs", "env", "validateInputs", "validateInputs", "a", "b", "validateInputs", "i", "inputVariable", "transpose", "outputVariable", "innerElementSize", "pad", "validateInputs", "convInputs", "transposedWeight", "validateInputs", "validateInputs", "permFunctionBody", "symbol", "reduceOps", "validateInputs", "calculateOutputShape", "fastGelu", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "inputs", "outputSize", "validateInputs", "weightTransposeAttribute", "validateInputs", "validateInputs", "validateInputs", "weightTransposeAttribute", "validateInputs", "validateInputs", "validateInputs", "dataType", "validateInputs", "validateInputs", "env", "validateInputs", "env", "validateInputs", "validateInputs", "validateInputs", "validateInputs", "components", "validateInputs", "getOutputShape", "a", "b", "c", "fastGelu", "env", "i", "env", "env", "wasm", "location", "index", "tensor", "errorCode", "i", "initializing", "initialized", "aborted", "copyFromExternalBuffer", "createSession", "releaseSession", "run", "endProfiling", "env", "Tensor", "copyFromExternalBuffer", "createSession", "releaseSession", "run", "endProfiling", "env", "InferenceSession", "Tensor", "env", "version", "wasmBackend", "env", "version"]
}
