oidn-web 0.3.3 → 0.3.5

package/dist/oidn.js

@@ -110,7 +110,7 @@ function xf(n) {
  * =============================================================================
  */
 const Sf = 1e-7, vf = 1e-4;
-class $f {
+class If {
   constructor(t, e) {
     this.backend = t, this.dataMover = e, this.data = /* @__PURE__ */ new WeakMap(), this.dataIdsCount = 0;
   }
@@ -201,7 +201,7 @@ function Bt(n) {
  * limitations under the License.
  * =============================================================================
  */
-function If(n) {
+function $f(n) {
   let t = n.length, e = 0;
   for (; t > 0; )
     e = Math.random() * t | 0, t--, En(n, t, e);
@@ -583,7 +583,7 @@ function ai(n, t) {
     return e.set(n, s), e.get(n);
   }
 }
-const Ff = "Abs", Vl = "Add", zf = "All", Uf = "ArgMax", Wf = "AvgPool", Gf = "AvgPool3D", Vf = "BatchMatMul", qf = "Bincount", ql = "Cast", jf = "ClipByValue", Hf = "Complex", Kf = "ComplexAbs", jl = "Concat", Yf = "Conv2D", Xf = "Conv2DBackpropFilter", Jf = "Conv2DBackpropInput", Zf = "Conv3D", Qf = "Conv3DBackpropInputV2", td = "CropAndResize", ed = "DepthwiseConv2dNative", nd = "RealDiv", sd = "Einsum", rd = "Elu", od = "Erf", id = "Equal", ad = "Exp", ld = "ExpandDims", ud = "Fill", cd = "FlipLeftRight", hd = "Floor", fd = "FloorDiv", dd = "GatherV2", pd = "Greater", md = "GreaterEqual", li = "Identity", gd = "Imag", bd = "LeakyRelu", yd = "Less", wd = "LessEqual", xd = "Log", Sd = "Log1p", vd = "LogicalAnd", $d = "Max", Id = "Maximum", Hl = "MaxPool", Ad = "MaxPool3D", Ed = "Mean", _d = "Min", Cd = "Minimum", kd = "MirrorPad", Td = "Multiply", Nd = "Neg", Dd = "NonMaxSuppressionV3", Pd = "NonMaxSuppressionV4", Rd = "NonMaxSuppressionV5", Ld = "OnesLike", Od = "OneHot", Md = "Pack", Kl = "PadV2", Bd = "Pow", Fd = "Prelu", zd = "Range", Ud = "Real", Wd = "Relu", Gd = "Reshape", Yl = "ResizeNearestNeighbor", Vd = "ResizeBilinear", qd = "Relu6", jd = "Round", Hd = "Select", Kd = "Selu", Xl = "Slice", Yd = "Sigmoid", Xd = "Softplus", Jd = "Sqrt", Zd = "Sum", Qd = "SplitV", tp = "Softmax", ep = "Sub", np = "Tanh", Jl = "Tile", sp = "Transform", io = "Transpose", rp = "Unpack", op = "ZerosLike", ip = "Step", ap = "RotateWithOffset", No = "FusedConv2D";
+const Ff = "Abs", Vl = "Add", zf = "All", Uf = "ArgMax", Wf = "AvgPool", Gf = "AvgPool3D", Vf = "BatchMatMul", qf = "Bincount", ql = "Cast", jf = "ClipByValue", Hf = "Complex", Kf = "ComplexAbs", jl = "Concat", Yf = "Conv2D", Xf = "Conv2DBackpropFilter", Jf = "Conv2DBackpropInput", Zf = "Conv3D", Qf = "Conv3DBackpropInputV2", td = "CropAndResize", ed = "DepthwiseConv2dNative", nd = "RealDiv", sd = "Einsum", rd = "Elu", od = "Erf", id = "Equal", ad = "Exp", ld = "ExpandDims", ud = "Fill", cd = "FlipLeftRight", hd = "Floor", fd = "FloorDiv", dd = "GatherV2", pd = "Greater", md = "GreaterEqual", li = "Identity", gd = "Imag", bd = "LeakyRelu", yd = "Less", wd = "LessEqual", xd = "Log", Sd = "Log1p", vd = "LogicalAnd", Id = "Max", $d = "Maximum", Hl = "MaxPool", Ad = "MaxPool3D", Ed = "Mean", _d = "Min", Cd = "Minimum", kd = "MirrorPad", Td = "Multiply", Nd = "Neg", Dd = "NonMaxSuppressionV3", Pd = "NonMaxSuppressionV4", Rd = "NonMaxSuppressionV5", Ld = "OnesLike", Od = "OneHot", Md = "Pack", Kl = "PadV2", Bd = "Pow", Fd = "Prelu", zd = "Range", Ud = "Real", Wd = "Relu", Gd = "Reshape", Yl = "ResizeNearestNeighbor", Vd = "ResizeBilinear", qd = "Relu6", jd = "Round", Hd = "Select", Kd = "Selu", Xl = "Slice", Yd = "Sigmoid", Xd = "Softplus", Jd = "Sqrt", Zd = "Sum", Qd = "SplitV", tp = "Softmax", ep = "Sub", np = "Tanh", Jl = "Tile", sp = "Transform", io = "Transpose", rp = "Unpack", op = "ZerosLike", ip = "Step", ap = "RotateWithOffset", No = "FusedConv2D";
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -1394,7 +1394,7 @@ function au(n, t, e) {
 function rt(n, t) {
   return au(n, t, 8);
 }
-function $a(n, t) {
+function Ia(n, t) {
   return au(n, t, 4);
 }
 function bt(n, t) {
@@ -1420,8 +1420,8 @@ function gp(n, t = n.length) {
     return We(o, i, e);
   }
   if (t >= 4) {
-    const e = kt.add(t * 2), s = $a(n, 0);
-    return We(s.shl(3).add(t), $a(n, t - 4), e);
+    const e = kt.add(t * 2), s = Ia(n, 0);
+    return We(s.shl(3).add(t), Ia(n, t - 4), e);
   }
   if (t > 0) {
     const e = n[0], s = n[t >> 1], r = n[t - 1], o = e + (s << 8), i = t + (r << 2);
@@ -1537,7 +1537,7 @@ function fn(n, t = [], e = !1) {
  */
 class vp {
   constructor(t, e) {
-    this.backendTimer = t, this.logger = e, e == null && (this.logger = new Ip());
+    this.backendTimer = t, this.logger = e, e == null && (this.logger = new $p());
   }
   profileKernel(t, e, s) {
     let r;
@@ -1558,7 +1558,7 @@ class vp {
       for (let u = 0; u < r.length; u++) {
         const c = r[u];
         c.data().then((h) => {
-          $p(h, c.dtype, t);
+          Ip(h, c.dtype, t);
         });
       }
     return {
@@ -1578,7 +1578,7 @@ class vp {
     });
   }
 }
-function $p(n, t, e) {
+function Ip(n, t, e) {
   if (t !== "float32")
     return !1;
   for (let s = 0; s < n.length; s++) {
@@ -1588,7 +1588,7 @@ function $p(n, t, e) {
   }
   return !1;
 }
-class Ip {
+class $p {
   logKernelProfile(t, e, s, r, o, i) {
     const a = typeof r == "number" ? tr(`${r}ms`, 9) : r.error, l = tr(t, 25), u = e.rank, c = e.size, h = tr(e.shape.toString(), 14);
     let f = "";
@@ -1706,7 +1706,7 @@ function Ep(n, t, e, s) {
  * limitations under the License.
  * =============================================================================
  */
-const Ia = 20, ss = 3, ao = 7;
+const $a = 20, ss = 3, ao = 7;
 function _p(n, t, e, s) {
   const r = Kt(t), o = Cp(n, t, e, r), i = t.length, a = er(n, t, e, r, o), l = ["Tensor"];
   return s && (l.push(`  dtype: ${e}`), l.push(`  rank: ${i}`), l.push(`  shape: [${t}]`), l.push("  values:")), l.push(a.map((u) => "    " + u).join(`
@@ -1740,7 +1740,7 @@ function er(n, t, e, s, r, o = !0) {
     return e === "bool" ? [lu(n[0])] : [n[0].toString()];
   }
   if (l === 1) {
-    if (a > Ia) {
+    if (a > $a) {
       const m = ss * i;
       let b = Array.from(n.slice(0, m)), y = Array.from(n.slice((a - ss) * i, a * i));
       return e === "complex64" && (b = us(b), y = us(y)), [
@@ -1752,7 +1752,7 @@ function er(n, t, e, s, r, o = !0) {
     ];
   }
   const u = t.slice(1), c = s.slice(1), h = s[0] * i, f = [];
-  if (a > Ia) {
+  if (a > $a) {
     for (let g = 0; g < ss; g++) {
       const m = g * h, b = m + h;
       f.push(...er(
@@ -2329,7 +2329,7 @@ class Mn {
   /**
    * Initializes a backend by looking up the backend name in the factory
    * registry and calling the factory method. Returns a boolean representing
-   * whether the initialization of the backend succeeded. Throws an error if
+   * whether the initialization of the backend suceeded. Throws an error if
    * there is no backend in the factory registry.
    */
   initializeBackend(t) {
@@ -2844,7 +2844,7 @@ function _a(n, t, e, s) {
       throw new Error(`Argument '${e}' passed to '${s}' must be ${n} tensor, but got ${t} tensor`);
   }
 }
-function I(n, t, e, s = "numeric") {
+function $(n, t, e, s = "numeric") {
   if (n instanceof uu())
     return _a(s, n.dtype, t, e), n;
   let r = Cs(n);
@@ -2860,7 +2860,7 @@ function I(n, t, e, s = "numeric") {
 function gu(n, t, e, s = "numeric") {
   if (!Array.isArray(n))
     throw new Error(`Argument ${t} passed to ${e} must be a \`Tensor[]\` or \`TensorLike[]\``);
-  return n.map((o, i) => I(o, `${t}[${i}]`, e, s));
+  return n.map((o, i) => $(o, `${t}[${i}]`, e, s));
 }
 /**
  * @license
@@ -2996,7 +2996,7 @@ function C(n) {
  * =============================================================================
  */
 function Mp(n, t, e = 0) {
-  const s = I(n, "x", "pad");
+  const s = $(n, "x", "pad");
   if (s.rank === 0)
     throw new Error("pad(scalar) is not defined. Pass non-scalar to pad");
   const r = { paddings: t, constantValue: e }, o = { x: s };
@@ -3024,7 +3024,7 @@ const zp = /* @__PURE__ */ C({ pad4d_: Fp });
  * =============================================================================
  */
 function Up(n, t, e) {
-  const s = I(n, "x", "slice", "string_or_numeric");
+  const s = $(n, "x", "slice", "string_or_numeric");
   if (s.rank === 0)
     throw new Error("Slicing scalar is not possible");
   const r = { x: s }, o = { begin: t, size: e };
@@ -3048,7 +3048,7 @@ const At = /* @__PURE__ */ C({ slice_: Up });
  * =============================================================================
  */
 function Wp(n, t, e) {
-  const s = I(n, "x", "slice4d");
+  const s = $(n, "x", "slice4d");
   return w(s.rank === 4, () => `slice4d expects a rank-4 tensor, but got a rank-${s.rank} tensor`), At(s, t, e);
 }
 const ws = /* @__PURE__ */ C({ slice4d_: Wp });
@@ -3069,7 +3069,7 @@ const ws = /* @__PURE__ */ C({ slice4d_: Wp });
  * =============================================================================
  */
 function Gp(n) {
-  const e = { x: I(n, "x", "clone", "string_or_numeric") };
+  const e = { x: $(n, "x", "clone", "string_or_numeric") };
   return A.runKernel(li, e);
 }
 const sn = /* @__PURE__ */ C({ clone_: Gp });
@@ -3175,7 +3175,7 @@ Pt.registerFlag("USE_SETTIMEOUTCUSTOM", () => !1);
  * =============================================================================
  */
 function Kp(n, t) {
-  const e = I(n, "real", "complex"), s = I(t, "imag", "complex");
+  const e = $(n, "real", "complex"), s = $(t, "imag", "complex");
   Ef(e.shape, s.shape, `real and imag shapes, ${e.shape} and ${s.shape}, must match in call to tf.complex().`);
   const r = { real: e, imag: s };
   return A.runKernel(Hf, r);
@@ -3722,9 +3722,9 @@ class pn {
   }
 }
 pn.URL_SCHEME = "localstorage://";
-const $u = (n) => V().getBool("IS_BROWSER") && !Array.isArray(n) && n.startsWith(pn.URL_SCHEME) ? fm(n.slice(pn.URL_SCHEME.length)) : null;
-Ct.registerSaveRouter($u);
-Ct.registerLoadRouter($u);
+const Iu = (n) => V().getBool("IS_BROWSER") && !Array.isArray(n) && n.startsWith(pn.URL_SCHEME) ? fm(n.slice(pn.URL_SCHEME.length)) : null;
+Ct.registerSaveRouter(Iu);
+Ct.registerLoadRouter(Iu);
 function fm(n) {
   return new pn(n);
 }
@@ -3946,7 +3946,7 @@ function vt(n, t = "float32", e) {
  * =============================================================================
  */
 function bm(n, t) {
-  const e = I(n, "x", "cast");
+  const e = $(n, "x", "cast");
   if (!Tf(t))
     throw new Error(`Failed to cast to unknown dtype ${t}`);
   if (t === "string" && e.dtype !== "string" || t !== "string" && e.dtype === "string")
@@ -4015,7 +4015,7 @@ Tp(wm);
  * =============================================================================
  */
 function xm(n, t) {
-  let e = I(n, "a", "add"), s = I(t, "b", "add");
+  let e = $(n, "a", "add"), s = $(t, "b", "add");
   [e, s] = Rt(e, s);
   const r = { a: e, b: s };
   return A.runKernel(Vl, r);
@@ -4038,7 +4038,7 @@ const M = /* @__PURE__ */ C({ add_: xm });
  * =============================================================================
  */
 function Sm(n, t) {
-  let e = I(n, "a", "floorDiv"), s = I(t, "b", "floorDiv");
+  let e = $(n, "a", "floorDiv"), s = $(t, "b", "floorDiv");
   [e, s] = Rt(e, s);
   const r = { a: e, b: s };
   return A.runKernel(fd, r);
@@ -4060,14 +4060,14 @@ const vm = /* @__PURE__ */ C({ floorDiv_: Sm });
  * limitations under the License.
  * =============================================================================
  */
-function $m(n, t) {
-  let e = I(n, "a", "div"), s = I(t, "b", "div");
+function Im(n, t) {
+  let e = $(n, "a", "div"), s = $(t, "b", "div");
   if ([e, s] = Rt(e, s), e.dtype === "int32" && s.dtype === "int32")
     return vm(e, s);
   const r = { a: e, b: s }, o = {};
   return A.runKernel(nd, r, o);
 }
-const Y = /* @__PURE__ */ C({ div_: $m });
+const Y = /* @__PURE__ */ C({ div_: Im });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -4084,13 +4084,13 @@ const Y = /* @__PURE__ */ C({ div_: $m });
  * limitations under the License.
  * =============================================================================
  */
-function Im(n, t) {
-  let e = I(n, "a", "mul"), s = I(t, "b", "mul");
+function $m(n, t) {
+  let e = $(n, "a", "mul"), s = $(t, "b", "mul");
   [e, s] = Rt(e, s);
   const r = { a: e, b: s };
   return A.runKernel(Td, r);
 }
-const N = /* @__PURE__ */ C({ mul_: Im });
+const N = /* @__PURE__ */ C({ mul_: $m });
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -4108,7 +4108,7 @@ const N = /* @__PURE__ */ C({ mul_: Im });
  * =============================================================================
  */
 function Am(n) {
-  const t = I(n, "x", "abs");
+  const t = $(n, "x", "abs");
   if (t.dtype === "complex64") {
     const e = { x: t };
     return A.runKernel(Kf, e);
@@ -4135,7 +4135,7 @@ const Nt = /* @__PURE__ */ C({ abs_: Am });
  * =============================================================================
  */
 function Em(n, t = null, e = !1) {
-  const r = { x: I(n, "x", "all", "bool") }, o = { axis: t, keepDims: e };
+  const r = { x: $(n, "x", "all", "bool") }, o = { axis: t, keepDims: e };
   return A.runKernel(zf, r, o);
 }
 const _m = /* @__PURE__ */ C({ all_: Em });
@@ -4156,7 +4156,7 @@ const _m = /* @__PURE__ */ C({ all_: Em });
  * =============================================================================
  */
 function Cm(n, t = 0) {
-  const s = { x: I(n, "x", "argMax") }, r = { axis: t };
+  const s = { x: $(n, "x", "argMax") }, r = { axis: t };
   return A.runKernel(Uf, s, r);
 }
 const hr = /* @__PURE__ */ C({ argMax_: Cm });
@@ -4318,7 +4318,7 @@ function Te(n, t, e) {
  * =============================================================================
  */
 function Rm(n, t) {
-  const s = { x: I(n, "x", "reshape", "string_or_numeric") }, r = { shape: t };
+  const s = { x: $(n, "x", "reshape", "string_or_numeric") }, r = { shape: t };
   return A.runKernel(Gd, s, r);
 }
 const L = /* @__PURE__ */ C({ reshape_: Rm });
@@ -4339,7 +4339,7 @@ const L = /* @__PURE__ */ C({ reshape_: Rm });
  * =============================================================================
  */
 function Lm(n, t, e, s, r) {
-  const o = I(n, "x", "avgPool", "float32"), i = 1;
+  const o = $(n, "x", "avgPool", "float32"), i = 1;
   w(Vn(e, i), () => `Error in avgPool: Either strides or dilations must be 1. Got strides ${e} and dilations '${i}'`);
   let a = o, l = !1;
   o.rank === 3 && (l = !0, a = L(o, [1, o.shape[0], o.shape[1], o.shape[2]])), w(a.rank === 4, () => `Error in avgPool: x must be rank 4 but got rank ${a.rank}.`), Te("avgPool", s, r);
@@ -4365,7 +4365,7 @@ const Om = /* @__PURE__ */ C({ avgPool_: Lm });
  * =============================================================================
  */
 function Mm(n, t, e, s, r, o = "NDHWC") {
-  const i = I(n, "x", "avgPool3d", "float32");
+  const i = $(n, "x", "avgPool3d", "float32");
   let a = i, l = !1;
   i.rank === 4 && (l = !0, a = L(i, [1, i.shape[0], i.shape[1], i.shape[2], i.shape[3]])), w(a.rank === 5, () => `Error in avgPool3d: x must be rank 5 but got rank ${a.rank}.`), w(o === "NDHWC", () => `Error in avgPool3d: Only NDHWC is currently supported, but got dataFormat of ${o}`), w(typeof e == "number" && e > 0 || Array.isArray(e) && e[0] > 0 && e[1] > 0 && e[2] > 0, () => `Error in avgPool3d: Stride must be > 0, but got '${e}'`), Te("avgPool3d", s, r);
   const u = { x: a }, c = { filterSize: t, strides: e, pad: s, dimRoundingMode: r, dataFormat: o };
@@ -4390,7 +4390,7 @@ const Bm = /* @__PURE__ */ C({ avgPool3d_: Mm });
  * =============================================================================
  */
 function Fm(n, t, e = !1, s = !1) {
-  let r = I(n, "a", "matMul"), o = I(t, "b", "matMul");
+  let r = $(n, "a", "matMul"), o = $(t, "b", "matMul");
   [r, o] = Rt(r, o);
   const i = { a: r, b: o }, a = { transposeA: e, transposeB: s };
   return A.runKernel(Vf, i, a);
@@ -4413,7 +4413,7 @@ const we = /* @__PURE__ */ C({ matMul_: Fm });
  * =============================================================================
  */
 function zm(n) {
-  const e = { x: I(n, "x", "sigmoid", "float32") };
+  const e = { x: $(n, "x", "sigmoid", "float32") };
   return A.runKernel(Yd, e);
 }
 const pi = /* @__PURE__ */ C({ sigmoid_: zm });
@@ -4434,7 +4434,7 @@ const pi = /* @__PURE__ */ C({ sigmoid_: zm });
  * =============================================================================
  */
 function Um(n) {
-  const e = { x: I(n, "x", "tanh", "float32") };
+  const e = { x: $(n, "x", "tanh", "float32") };
   return A.runKernel(np, e);
 }
 const mi = /* @__PURE__ */ C({ tanh_: Um });
@@ -4455,7 +4455,7 @@ const mi = /* @__PURE__ */ C({ tanh_: Um });
  * =============================================================================
  */
 function Wm(n, t, e) {
-  const s = I(n, "x", "bincount"), r = I(t, "weights", "bincount");
+  const s = $(n, "x", "bincount"), r = $(t, "weights", "bincount");
   w(s.dtype === "int32", () => `Error in bincount: input dtype must be int32, but got ${s.dtype}`), w(e >= 0, () => `size must be non-negative, but got ${e}.`), w(r.size === s.size || r.size === 0, () => `Error in bincount: weights must have the same size as input or0-length, but got input shape: ${s.shape}, weights shape: ${r.shape}.`);
   const o = { x: s, weights: r }, i = { size: e };
   return A.runKernel(qf, o, i);
@@ -4478,7 +4478,7 @@ const Gm = /* @__PURE__ */ C({ bincount_: Wm });
  * =============================================================================
  */
 function Vm(n, t) {
-  let e = I(n, "broadcastTo", "x");
+  let e = $(n, "broadcastTo", "x");
   const s = e.shape;
   if (Me(t), t.length < e.rank)
     throw new Error(`broadcastTo(): shape.length=${t.length} < input.rank=${e.rank}.`);
@@ -4538,7 +4538,7 @@ function Vr(n, t, e) {
  * =============================================================================
  */
 function qm(n, t, e) {
-  const s = I(n, "x", "clipByValue");
+  const s = $(n, "x", "clipByValue");
   if (w(t <= e, () => `Error in clip: min (${t}) must be less than or equal to max (${e}).`), t === e)
     return Vr(s.shape, t, s.dtype);
   const r = { x: s }, o = { clipValueMin: t, clipValueMax: e };
@@ -4562,7 +4562,7 @@ const pe = /* @__PURE__ */ C({ clipByValue_: qm });
  * =============================================================================
  */
 function jm(n, t, e, s, r = "NHWC", o = [1, 1], i) {
-  const a = I(n, "x", "conv2d", "float32"), l = I(t, "filter", "conv2d", "float32");
+  const a = $(n, "x", "conv2d", "float32"), l = $(t, "filter", "conv2d", "float32");
   let u = a, c = !1;
   a.rank === 3 && (c = !0, u = L(a, [1, a.shape[0], a.shape[1], a.shape[2]])), w(u.rank === 4, () => `Error in conv2d: input must be rank 4, but got rank ${u.rank}.`), w(l.rank === 4, () => `Error in conv2d: filter must be rank 4, but got rank ${l.rank}.`), Te("conv2d", s, i);
   const h = r === "NHWC" ? u.shape[3] : u.shape[1];
@@ -4572,7 +4572,7 @@ function jm(n, t, e, s, r = "NHWC", o = [1, 1], i) {
 }
 const gi = /* @__PURE__ */ C({ conv2d_: jm });
 function Hm(n, t, e, s, r = "NWC", o = 1, i) {
-  const a = I(n, "x", "conv1d"), l = I(t, "filter", "conv1d");
+  const a = $(n, "x", "conv1d"), l = $(t, "filter", "conv1d");
   let u = a, c = !1;
   a.rank === 2 && (c = !0, u = L(a, [1, a.shape[0], a.shape[1]])), w(u.rank === 3, () => `Error in conv1d: input must be rank 3, but got rank ${u.rank}.`), w(l.rank === 3, () => `Error in conv1d: filter must be rank 3, but got rank ${l.rank}.`), Te("conv1d", s, i), w(u.shape[2] === l.shape[1], () => `Error in conv1d: depth of input (${u.shape[2]}) must match input depth for filter ${l.shape[1]}.`), w(Vn(e, o), () => `Error in conv1D: Either stride or dilation must be 1. Got stride ${e} and dilation '${o}'`), w(Bn(o), () => "Error in conv1D: Dilated rates should be larger than 0."), w(Bn(e), () => "Error in conv1D: Stride should be larger than 0."), w(r === "NWC", () => `Error in conv1d: got dataFormat of ${r} but only NWC is currently supported.`);
   const h = L(l, [1, l.shape[0], l.shape[1], l.shape[2]]), f = L(u, [u.shape[0], 1, u.shape[1], u.shape[2]]), m = gi(f, h, [1, e], s, "NHWC", [1, o], i);
@@ -4604,10 +4604,10 @@ function Ym(n, t, e, s, r, o = "NHWC", i) {
   const f = { dy: l, filter: e }, d = { strides: s, pad: r, dataFormat: o, dimRoundingMode: i, inputShape: a }, p = A.runKernel(Jf, f, d);
   return u ? L(p, [p.shape[1], p.shape[2], p.shape[3]]) : p;
 }
-const Iu = /* @__PURE__ */ C({ conv2DBackpropInput_: Ym });
+const $u = /* @__PURE__ */ C({ conv2DBackpropInput_: Ym });
 function Xm(n, t, e, s, r, o) {
-  const i = I(n, "x", "conv2dTranspose"), a = I(t, "filter", "conv2dTranspose");
-  return Iu(e, i, a, s, r, "NHWC", o);
+  const i = $(n, "x", "conv2dTranspose"), a = $(t, "filter", "conv2dTranspose");
+  return $u(e, i, a, s, r, "NHWC", o);
 }
 const Jm = /* @__PURE__ */ C({ conv2dTranspose_: Xm });
 /**
@@ -4627,7 +4627,7 @@ const Jm = /* @__PURE__ */ C({ conv2dTranspose_: Xm });
  * =============================================================================
  */
 function Zm(n, t, e, s, r = "NDHWC", o = [1, 1, 1]) {
-  const i = I(n, "x", "conv3d"), a = I(t, "filter", "conv3d");
+  const i = $(n, "x", "conv3d"), a = $(t, "filter", "conv3d");
   let l = i, u = !1;
   i.rank === 4 && (u = !0, l = L(i, [1, i.shape[0], i.shape[1], i.shape[2], i.shape[3]])), w(l.rank === 5, () => `Error in conv3d: input must be rank 5, but got rank ${l.rank}.`), w(a.rank === 5, () => `Error in conv3d: filter must be rank 5, but got rank ${a.rank}.`), w(l.shape[4] === a.shape[3], () => `Error in conv3d: depth of input (${l.shape[4]}) must match input depth for filter ${a.shape[3]}.`), w(Vn(e, o), () => `Error in conv3D: Either strides or dilations must be 1. Got strides ${e} and dilations '${o}'`), w(r === "NDHWC", () => `Error in conv3d: got dataFormat of ${r} but only NDHWC is currently supported.`), w(Bn(o), () => "Error in conv3D: Dilated rates should be larger than 0."), w(Bn(e), () => "Error in conv3D: Strides should be larger than 0.");
   const c = { x: l, filter: a }, h = { strides: e, pad: s, dataFormat: r, dilations: o }, f = A.runKernel(Zf, c, h);
@@ -4661,7 +4661,7 @@ function tg(n, t, e, s, r) {
 }
 const eg = /* @__PURE__ */ C({ conv3DBackpropInput_: tg });
 function ng(n, t, e, s, r) {
-  const o = I(n, "x", "conv3dTranspose"), i = I(t, "filter", "conv3dTranspose");
+  const o = $(n, "x", "conv3dTranspose"), i = $(t, "filter", "conv3dTranspose");
   return eg(e, o, i, s, r);
 }
 const sg = /* @__PURE__ */ C({ conv3dTranspose_: ng });
@@ -4682,7 +4682,7 @@ const sg = /* @__PURE__ */ C({ conv3dTranspose_: ng });
  * =============================================================================
  */
 function rg(n, t, e, s, r = "NHWC", o = [1, 1], i) {
-  const a = I(n, "x", "depthwiseConv2d", "float32"), l = I(t, "filter", "depthwiseConv2d", "float32");
+  const a = $(n, "x", "depthwiseConv2d", "float32"), l = $(t, "filter", "depthwiseConv2d", "float32");
   let u = a, c = !1;
   a.rank === 3 && (c = !0, u = L(a, [1, a.shape[0], a.shape[1], a.shape[2]])), w(u.rank === 4, () => `Error in depthwiseConv2d: input must be rank 4, but got rank ${u.rank}.`), w(l.rank === 4, () => `Error in depthwiseConv2d: filter must be rank 4, but got rank ${l.rank}.`);
   const h = r === "NHWC" ? u.shape[3] : u.shape[1];
@@ -4758,7 +4758,7 @@ function Wt(n, t) {
  * =============================================================================
  */
 function ag(n, t) {
-  let e = I(n, "a", "equal", "string_or_numeric"), s = I(t, "b", "equal", "string_or_numeric");
+  let e = $(n, "a", "equal", "string_or_numeric"), s = $(t, "b", "equal", "string_or_numeric");
   [e, s] = Rt(e, s), Wt(e.shape, s.shape);
   const r = { a: e, b: s };
   return A.runKernel(id, r);
@@ -4781,7 +4781,7 @@ const mn = /* @__PURE__ */ C({ equal_: ag });
  * =============================================================================
  */
 function lg(n, t, e) {
-  const s = I(t, "a", "where"), r = I(e, "b", "where"), o = I(n, "condition", "where", "bool"), i = Wt(Wt(o.shape, s.shape), r.shape), a = sr(o, i), l = sr(s, i), u = sr(r, i), c = {
+  const s = $(t, "a", "where"), r = $(e, "b", "where"), o = $(n, "condition", "where", "bool"), i = Wt(Wt(o.shape, s.shape), r.shape), a = sr(o, i), l = sr(s, i), u = sr(r, i), c = {
     condition: a,
     t: l,
     e: u
@@ -4806,7 +4806,7 @@ const on = /* @__PURE__ */ C({ where_: lg });
  * =============================================================================
  */
 function ug(n) {
-  const e = { x: I(n, "x", "zerosLike") };
+  const e = { x: $(n, "x", "zerosLike") };
   return A.runKernel(op, e);
 }
 const _e = /* @__PURE__ */ C({ zerosLike_: ug });
@@ -4827,7 +4827,7 @@ const _e = /* @__PURE__ */ C({ zerosLike_: ug });
  * =============================================================================
  */
 function cg(n, ...t) {
-  const e = t.map((r, o) => I(r, `tensors${o}`, "einsum")), s = { equation: n };
+  const e = t.map((r, o) => $(r, `tensors${o}`, "einsum")), s = { equation: n };
   return A.runKernel(sd, e, s);
 }
 const rs = /* @__PURE__ */ C({ einsum_: cg });
@@ -4848,7 +4848,7 @@ const rs = /* @__PURE__ */ C({ einsum_: cg });
  * =============================================================================
  */
 function hg(n) {
-  const e = { x: I(n, "x", "elu", "float32") };
+  const e = { x: $(n, "x", "elu", "float32") };
   return A.runKernel(rd, e);
 }
 const Au = /* @__PURE__ */ C({ elu_: hg });
@@ -4869,7 +4869,7 @@ const Au = /* @__PURE__ */ C({ elu_: hg });
  * =============================================================================
  */
 function fg(n) {
-  let t = I(n, "x", "erf");
+  let t = $(n, "x", "erf");
   w(t.dtype === "int32" || t.dtype === "float32", () => "Input dtype must be `int32` or `float32`."), t.dtype === "int32" && (t = ot(t, "float32"));
   const e = { x: t };
   return A.runKernel(od, e);
@@ -4949,8 +4949,8 @@ function bg(n, t) {
  * =============================================================================
  */
 function yg(n, t = null, e = !1) {
-  const r = { x: I(n, "x", "max") }, o = { reductionIndices: t, keepDims: e };
-  return A.runKernel($d, r, o);
+  const r = { x: $(n, "x", "max") }, o = { reductionIndices: t, keepDims: e };
+  return A.runKernel(Id, r, o);
 }
 const Ge = /* @__PURE__ */ C({ max_: yg });
 /**
@@ -4970,7 +4970,7 @@ const Ge = /* @__PURE__ */ C({ max_: yg });
  * =============================================================================
  */
 function wg(n, t = null, e = !1) {
-  const r = { x: I(n, "x", "min") }, o = { axis: t, keepDims: e };
+  const r = { x: $(n, "x", "min") }, o = { axis: t, keepDims: e };
   return A.runKernel(_d, r, o);
 }
 const Pa = /* @__PURE__ */ C({ min_: wg });
@@ -4991,7 +4991,7 @@ const Pa = /* @__PURE__ */ C({ min_: wg });
  * =============================================================================
  */
 function xg(n, t) {
-  let e = I(n, "base", "pow"), s = I(t, "exp", "pow");
+  let e = $(n, "base", "pow"), s = $(t, "exp", "pow");
   [e, s] = Rt(e, s);
   const r = { a: e, b: s };
   return A.runKernel(Bd, r);
@@ -5037,7 +5037,7 @@ function Yt(n, t) {
  * =============================================================================
  */
 function Sg(n) {
-  const e = { x: I(n, "x", "sqrt", "float32") };
+  const e = { x: $(n, "x", "sqrt", "float32") };
   return A.runKernel(Jd, e);
 }
 const me = /* @__PURE__ */ C({ sqrt_: Sg });
@@ -5058,7 +5058,7 @@ const me = /* @__PURE__ */ C({ sqrt_: Sg });
  * =============================================================================
  */
 function vg(n) {
-  const t = I(n, "x", "square"), e = {};
+  const t = $(n, "x", "square"), e = {};
   return A.runKernel("Square", { x: t }, e);
 }
 const Ve = /* @__PURE__ */ C({ square_: vg });
@@ -5078,13 +5078,13 @@ const Ve = /* @__PURE__ */ C({ square_: vg });
  * limitations under the License.
  * =============================================================================
  */
-function $g(n, t = null, e = !1) {
-  let s = I(n, "x", "sum");
+function Ig(n, t = null, e = !1) {
+  let s = $(n, "x", "sum");
   s.dtype === "bool" && (s = ot(s, "int32"));
   const r = { x: s }, o = { axis: t, keepDims: e };
   return A.runKernel(Zd, r, o);
 }
-const et = /* @__PURE__ */ C({ sum_: $g });
+const et = /* @__PURE__ */ C({ sum_: Ig });
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -5101,8 +5101,8 @@ const et = /* @__PURE__ */ C({ sum_: $g });
  * limitations under the License.
  * =============================================================================
  */
-function Ig(n, t = "euclidean", e = null, s = !1) {
-  n = I(n, "x", "norm");
+function $g(n, t = "euclidean", e = null, s = !1) {
+  n = $(n, "x", "norm");
   const r = Cu(n, t, e);
   let o = r.shape;
   if (s) {
@@ -5140,7 +5140,7 @@ function Cu(n, t, e = null) {
   }
   throw new Error(`Error in norm: invalid axis: ${e}`);
 }
-const ku = /* @__PURE__ */ C({ norm_: Ig });
+const ku = /* @__PURE__ */ C({ norm_: $g });
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -5158,7 +5158,7 @@ const ku = /* @__PURE__ */ C({ norm_: Ig });
  * =============================================================================
  */
 function Ag(n) {
-  const e = { x: I(n, "x", "exp") };
+  const e = { x: $(n, "x", "exp") };
   return A.runKernel(ad, e);
 }
 const Go = /* @__PURE__ */ C({ exp_: Ag });
@@ -5179,12 +5179,12 @@ const Go = /* @__PURE__ */ C({ exp_: Ag });
  * =============================================================================
  */
 function Eg(n, t = 0) {
-  const e = I(n, "x", "expandDims", "string_or_numeric");
+  const e = $(n, "x", "expandDims", "string_or_numeric");
   w(t <= e.rank, () => "Axis must be <= rank of the tensor");
   const s = { input: e }, r = { dim: t };
   return A.runKernel(ld, s, r);
 }
-const $e = /* @__PURE__ */ C({ expandDims_: Eg });
+const Ie = /* @__PURE__ */ C({ expandDims_: Eg });
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.
@@ -5202,7 +5202,7 @@ const $e = /* @__PURE__ */ C({ expandDims_: Eg });
  * =============================================================================
  */
 function _g(n, t) {
-  const e = I(n, "x", "tile", "string_or_numeric");
+  const e = $(n, "x", "tile", "string_or_numeric");
   w(e.rank === t.length, () => `Error in transpose: rank of input ${e.rank} must match length of reps ${t}.`);
   const s = { x: e }, r = { reps: t };
   return A.runKernel(Jl, s, r);
@@ -5233,11 +5233,11 @@ function Cg(n, t, e, s = "float32") {
   if (e == null)
     return i;
   if (e.length === 1)
-    return rr($e(i, 0), [e[0], 1, 1]);
+    return rr(Ie(i, 0), [e[0], 1, 1]);
   if (e.length === 2)
-    return rr($e($e(i, 0), 0), [e[0], e[1], 1, 1]);
+    return rr(Ie(Ie(i, 0), 0), [e[0], e[1], 1, 1]);
   if (e.length === 3)
-    return rr($e($e($e(i, 0), 0), 0), [
+    return rr(Ie(Ie(Ie(i, 0), 0), 0), [
       e[0],
       e[1],
       e[2],
@@ -5264,7 +5264,7 @@ const Tu = /* @__PURE__ */ C({ eye_: Cg });
  * =============================================================================
  */
 function kg(n) {
-  const e = { x: I(n, "x", "floor", "float32") };
+  const e = { x: $(n, "x", "floor", "float32") };
   return A.runKernel(hd, e);
 }
 const Tg = /* @__PURE__ */ C({ floor_: kg });
@@ -5285,7 +5285,7 @@ const Tg = /* @__PURE__ */ C({ floor_: kg });
  * =============================================================================
  */
 function Ng(n, t, e = 0, s = 0) {
-  const r = I(n, "x", "gather"), o = I(t, "indices", "gather", "int32"), i = { x: r, indices: o }, a = { axis: e, batchDims: s };
+  const r = $(n, "x", "gather"), o = $(t, "indices", "gather", "int32"), i = { x: r, indices: o }, a = { axis: e, batchDims: s };
   return A.runKernel(dd, i, a);
 }
 const Dg = /* @__PURE__ */ C({ gather_: Ng });
@@ -5306,7 +5306,7 @@ const Dg = /* @__PURE__ */ C({ gather_: Ng });
  * =============================================================================
  */
 function Pg(n, t) {
-  let e = I(n, "a", "greater", "string_or_numeric"), s = I(t, "b", "greater", "string_or_numeric");
+  let e = $(n, "a", "greater", "string_or_numeric"), s = $(t, "b", "greater", "string_or_numeric");
   [e, s] = Rt(e, s), Wt(e.shape, s.shape);
   const r = { a: e, b: s };
   return A.runKernel(pd, r);
@@ -5329,7 +5329,7 @@ const ks = /* @__PURE__ */ C({ greater_: Pg });
  * =============================================================================
  */
 function Rg(n, t) {
-  let e = I(n, "a", "greaterEqual", "string_or_numeric"), s = I(t, "b", "greaterEqual", "string_or_numeric");
+  let e = $(n, "a", "greaterEqual", "string_or_numeric"), s = $(t, "b", "greaterEqual", "string_or_numeric");
   [e, s] = Rt(e, s), Wt(e.shape, s.shape);
   const r = { a: e, b: s };
   return A.runKernel(md, r);
@@ -5352,7 +5352,7 @@ const Lg = /* @__PURE__ */ C({ greaterEqual_: Rg });
  * =============================================================================
  */
 function Og(n) {
-  const e = { input: I(n, "input", "imag") };
+  const e = { input: $(n, "input", "imag") };
   return A.runKernel(gd, e);
 }
 const Mg = /* @__PURE__ */ C({ imag_: Og });
@@ -5373,7 +5373,7 @@ const Mg = /* @__PURE__ */ C({ imag_: Og });
  * =============================================================================
  */
 function Bg(n, t = 0.2) {
-  const s = { x: I(n, "x", "leakyRelu") }, r = { alpha: t };
+  const s = { x: $(n, "x", "leakyRelu") }, r = { alpha: t };
   return A.runKernel(bd, s, r);
 }
 const Fg = /* @__PURE__ */ C({ leakyRelu_: Bg });
@@ -5394,7 +5394,7 @@ const Fg = /* @__PURE__ */ C({ leakyRelu_: Bg });
  * =============================================================================
  */
 function zg(n, t) {
-  let e = I(n, "a", "less", "string_or_numeric"), s = I(t, "b", "less", "string_or_numeric");
+  let e = $(n, "a", "less", "string_or_numeric"), s = $(t, "b", "less", "string_or_numeric");
   [e, s] = Rt(e, s), Wt(e.shape, s.shape);
   const r = { a: e, b: s };
   return A.runKernel(yd, r);
@@ -5417,7 +5417,7 @@ const Ra = /* @__PURE__ */ C({ less_: zg });
  * =============================================================================
  */
 function Ug(n, t) {
-  let e = I(n, "a", "lessEqual", "string_or_numeric"), s = I(t, "b", "lessEqual", "string_or_numeric");
+  let e = $(n, "a", "lessEqual", "string_or_numeric"), s = $(t, "b", "lessEqual", "string_or_numeric");
   [e, s] = Rt(e, s), Wt(e.shape, s.shape);
   const r = { a: e, b: s };
   return A.runKernel(wd, r);
@@ -5440,7 +5440,7 @@ const Nu = /* @__PURE__ */ C({ lessEqual_: Ug });
  * =============================================================================
  */
 function Wg(n) {
-  const e = { x: I(n, "x", "log", "float32") };
+  const e = { x: $(n, "x", "log", "float32") };
   return A.runKernel(xd, e);
 }
 const gn = /* @__PURE__ */ C({ log_: Wg });
@@ -5461,7 +5461,7 @@ const gn = /* @__PURE__ */ C({ log_: Wg });
  * =============================================================================
  */
 function Gg(n) {
-  const e = { x: I(n, "x", "log1p") };
+  const e = { x: $(n, "x", "log1p") };
   return A.runKernel(Sd, e);
 }
 const Vg = /* @__PURE__ */ C({ log1p_: Gg });
@@ -5518,7 +5518,7 @@ function Vo(n) {
  * =============================================================================
  */
 function jg(n) {
-  const e = { x: I(n, "x", "neg") };
+  const e = { x: $(n, "x", "neg") };
   return A.runKernel(Nd, e);
 }
 const qn = /* @__PURE__ */ C({ neg_: jg });
@@ -5539,7 +5539,7 @@ const qn = /* @__PURE__ */ C({ neg_: jg });
  * =============================================================================
  */
 function Hg(n) {
-  const e = { x: I(n, "x", "softplus") };
+  const e = { x: $(n, "x", "softplus") };
   return A.runKernel(Xd, e);
 }
 const yi = /* @__PURE__ */ C({ softplus_: Hg });
@@ -5560,7 +5560,7 @@ const yi = /* @__PURE__ */ C({ softplus_: Hg });
  * =============================================================================
  */
 function Kg(n, t) {
-  let e = I(n, "a", "sub"), s = I(t, "b", "sub");
+  let e = $(n, "a", "sub"), s = $(t, "b", "sub");
   [e, s] = Rt(e, s);
   const r = { a: e, b: s };
   return A.runKernel(ep, r);
@@ -5583,7 +5583,7 @@ const Z = /* @__PURE__ */ C({ sub_: Kg });
  * =============================================================================
  */
 function Yg(n, t = -1) {
-  const e = I(n, "logits", "logSoftmax");
+  const e = $(n, "logits", "logSoftmax");
   if (t === -1 && (t = e.rank - 1), t !== e.rank - 1)
     throw Error(`Log Softmax along a non-last dimension is not yet supported. Logits was rank ${e.rank} and axis was ${t}`);
   return Vo((r, o) => {
@@ -5612,7 +5612,7 @@ const Xg = /* @__PURE__ */ C({ logSoftmax_: Yg });
  * =============================================================================
  */
 function Jg(n, t) {
-  const e = I(n, "a", "logicalAnd", "bool"), s = I(t, "b", "logicalAnd", "bool");
+  const e = $(n, "a", "logicalAnd", "bool"), s = $(t, "b", "logicalAnd", "bool");
   Wt(e.shape, s.shape);
   const r = { a: e, b: s };
   return A.runKernel(vd, r);
@@ -5635,7 +5635,7 @@ const qr = /* @__PURE__ */ C({ logicalAnd_: Jg });
  * =============================================================================
  */
 function Zg(n, t, e, s, r) {
-  const o = I(n, "x", "maxPool"), i = 1;
+  const o = $(n, "x", "maxPool"), i = 1;
   let a = o, l = !1;
   o.rank === 3 && (l = !0, a = L(o, [1, o.shape[0], o.shape[1], o.shape[2]])), w(a.rank === 4, () => `Error in maxPool: input must be rank 4 but got rank ${a.rank}.`), w(Vn(e, i), () => `Error in maxPool: Either strides or dilations must be 1. Got strides ${e} and dilations '${i}'`), Te("maxPool", s, r);
   const u = { x: a }, c = { filterSize: t, strides: e, pad: s, dimRoundingMode: r }, h = A.runKernel(Hl, u, c);
@@ -5659,7 +5659,7 @@ const Qg = /* @__PURE__ */ C({ maxPool_: Zg });
  * =============================================================================
  */
 function t0(n, t = [1, 1, 1], e, s, r, o = "NDHWC") {
-  const i = I(n, "x", "maxPool3d");
+  const i = $(n, "x", "maxPool3d");
   let a = i, l = !1;
   i.rank === 4 && (l = !0, a = L(i, [1, i.shape[0], i.shape[1], i.shape[2], i.shape[3]])), w(a.rank === 5, () => `Error in maxPool3d: x must be rank 5 but got rank ${a.rank}.`), w(o === "NDHWC", () => `Error in maxPool3d: Only NDHWC is currently supported, but got dataFormat of ${o}`), Te("maxPool3d", s, r);
   const u = { x: a }, c = { filterSize: t, strides: e, pad: s, dimRoundingMode: r, dataFormat: o }, h = A.runKernel(Ad, u, c);
@@ -5683,10 +5683,10 @@ const e0 = /* @__PURE__ */ C({ maxPool3d_: t0 });
  * =============================================================================
  */
 function n0(n, t) {
-  let e = I(n, "a", "maximum"), s = I(t, "b", "maximum");
+  let e = $(n, "a", "maximum"), s = $(t, "b", "maximum");
   [e, s] = Rt(e, s), e.dtype === "bool" && (e = ot(e, "int32"), s = ot(s, "int32")), Wt(e.shape, s.shape);
   const r = { a: e, b: s };
-  return A.runKernel(Id, r);
+  return A.runKernel($d, r);
 }
 const jn = /* @__PURE__ */ C({ maximum_: n0 });
 /**
@@ -5706,7 +5706,7 @@ const jn = /* @__PURE__ */ C({ maximum_: n0 });
  * =============================================================================
  */
 function s0(n, t = null, e = !1) {
-  const r = { x: I(n, "x", "mean") }, o = { axis: t, keepDims: e };
+  const r = { x: $(n, "x", "mean") }, o = { axis: t, keepDims: e };
   return A.runKernel(Ed, r, o);
 }
 const St = /* @__PURE__ */ C({ mean_: s0 });
@@ -5775,7 +5775,7 @@ function wi(n, t = "float32") {
  * =============================================================================
  */
 function r0(n, t) {
-  let e = I(n, "a", "minimum"), s = I(t, "b", "minimum");
+  let e = $(n, "a", "minimum"), s = $(t, "b", "minimum");
   [e, s] = Rt(e, s), e.dtype === "bool" && (e = ot(e, "int32"), s = ot(s, "int32")), Wt(e.shape, s.shape);
   const r = { a: e, b: s };
   return A.runKernel(Cd, r);
@@ -5800,7 +5800,7 @@ const mr = /* @__PURE__ */ C({ minimum_: r0 });
 function o0(n, t, e = 1, s = 0, r = "int32") {
   if (t < 2)
     throw new Error(`Error in oneHot: depth must be >=2, but it is ${t}`);
-  const i = { indices: I(n, "indices", "oneHot", "int32") }, a = { dtype: r, depth: t, onValue: e, offValue: s };
+  const i = { indices: $(n, "indices", "oneHot", "int32") }, a = { dtype: r, depth: t, onValue: e, offValue: s };
   return A.runKernel(Od, i, a);
 }
 const i0 = /* @__PURE__ */ C({ oneHot_: o0 });
@@ -5821,7 +5821,7 @@ const i0 = /* @__PURE__ */ C({ oneHot_: o0 });
  * =============================================================================
  */
 function a0(n) {
-  const e = { x: I(n, "x", "onesLike") };
+  const e = { x: $(n, "x", "onesLike") };
   return A.runKernel(Ld, e);
 }
 const Du = /* @__PURE__ */ C({ onesLike_: a0 });
@@ -5842,7 +5842,7 @@ const Du = /* @__PURE__ */ C({ onesLike_: a0 });
  * =============================================================================
  */
 function l0(n, t) {
-  const e = I(n, "x", "prelu"), s = I(t, "alpha", "prelu"), r = { x: e, alpha: s };
+  const e = $(n, "x", "prelu"), s = $(t, "alpha", "prelu"), r = { x: e, alpha: s };
   return A.runKernel(Fd, r);
 }
 const u0 = /* @__PURE__ */ C({ prelu_: l0 });
@@ -5958,8 +5958,8 @@ vi.exports;
     n
   );
 })(vi);
-var f0 = vi.exports, $i = { exports: {} };
-$i.exports;
+var f0 = vi.exports, Ii = { exports: {} };
+Ii.exports;
 (function(n) {
   (function(t, e, s) {
     function r(a) {
@@ -6004,9 +6004,9 @@ $i.exports;
     wn,
     n
   );
-})($i);
-var d0 = $i.exports, Ii = { exports: {} };
-Ii.exports;
+})(Ii);
+var d0 = Ii.exports, $i = { exports: {} };
+$i.exports;
 (function(n) {
   (function(t, e, s) {
     function r(a) {
@@ -6048,8 +6048,8 @@ Ii.exports;
     // window object or global
     n
   );
-})(Ii);
-var p0 = Ii.exports, Ai = { exports: {} };
+})($i);
+var p0 = $i.exports, Ai = { exports: {} };
 Ai.exports;
 (function(n) {
   (function(t, e, s) {
@@ -6180,12 +6180,12 @@ const g0 = {}, b0 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineP
     // math: package containing random, pow, and seedrandom
   );
 })(Pu);
-var w0 = Pu.exports, x0 = c0, S0 = h0, v0 = f0, $0 = d0, I0 = p0, A0 = m0, Sn = w0;
+var w0 = Pu.exports, x0 = c0, S0 = h0, v0 = f0, I0 = d0, $0 = p0, A0 = m0, Sn = w0;
 Sn.alea = x0;
 Sn.xor128 = S0;
 Sn.xorwow = v0;
-Sn.xorshift7 = $0;
-Sn.xor4096 = I0;
+Sn.xorshift7 = I0;
+Sn.xor4096 = $0;
 Sn.tychei = A0;
 var Ru = Sn;
 /**
@@ -6337,7 +6337,7 @@ function gr(n, t, e = 1, s = "float32") {
  * =============================================================================
  */
 function T0(n) {
-  const e = { input: I(n, "input", "real") };
+  const e = { input: $(n, "input", "real") };
   return A.runKernel(Ud, e);
 }
 const N0 = /* @__PURE__ */ C({ real_: T0 });
@@ -6358,7 +6358,7 @@ const N0 = /* @__PURE__ */ C({ real_: T0 });
  * =============================================================================
  */
 function D0(n) {
-  const e = { x: I(n, "x", "relu") };
+  const e = { x: $(n, "x", "relu") };
   return A.runKernel(Wd, e);
 }
 const Ts = /* @__PURE__ */ C({ relu_: D0 });
@@ -6379,7 +6379,7 @@ const Ts = /* @__PURE__ */ C({ relu_: D0 });
  * =============================================================================
  */
 function P0(n) {
-  const e = { x: I(n, "x", "relu6") };
+  const e = { x: $(n, "x", "relu6") };
   return A.runKernel(qd, e);
 }
 const R0 = /* @__PURE__ */ C({ relu6_: P0 });
@@ -6400,7 +6400,7 @@ const R0 = /* @__PURE__ */ C({ relu6_: P0 });
  * =============================================================================
  */
 function L0(n) {
-  const e = { x: I(n, "x", "round") };
+  const e = { x: $(n, "x", "round") };
   return A.runKernel(jd, e);
 }
 const O0 = /* @__PURE__ */ C({ round_: L0 });
@@ -6421,12 +6421,12 @@ const O0 = /* @__PURE__ */ C({ round_: L0 });
  * =============================================================================
  */
 function M0(n) {
-  const e = { x: I(n, "x", "selu") };
+  const e = { x: $(n, "x", "selu") };
   return A.runKernel(Kd, e);
 }
 const B0 = /* @__PURE__ */ C({ selu_: M0 });
 function F0(n, t, e, s, r, o = [1, 1], i = "NHWC") {
-  const a = I(n, "x", "separableConv2d"), l = I(t, "depthwiseFilter", "separableConv2d"), u = I(e, "pointwiseFilter", "separableConv2d");
+  const a = $(n, "x", "separableConv2d"), l = $(t, "depthwiseFilter", "separableConv2d"), u = $(e, "pointwiseFilter", "separableConv2d");
   let c = a, h = !1;
   if (a.rank === 3 && (h = !0, c = L(a, [1, a.shape[0], a.shape[1], a.shape[2]])), i === "NCHW")
     throw new Error("separableConv2d currently does not support dataFormat NCHW; only NHWC is supported");
@@ -6454,7 +6454,7 @@ const z0 = /* @__PURE__ */ C({ separableConv2d_: F0 });
  * =============================================================================
  */
 function U0(n, t, e) {
-  const s = I(n, "x", "slice1d");
+  const s = $(n, "x", "slice1d");
   return w(s.rank === 1, () => `slice1d expects a rank-1 tensor, but got a rank-${s.rank} tensor`), At(s, [t], [e]);
 }
 const Ei = /* @__PURE__ */ C({ slice1d_: U0 });
@@ -6475,7 +6475,7 @@ const Ei = /* @__PURE__ */ C({ slice1d_: U0 });
  * =============================================================================
  */
 function W0(n, t, e) {
-  const s = I(n, "x", "slice2d");
+  const s = $(n, "x", "slice2d");
   return w(s.rank === 2, () => `slice2d expects a rank-2 tensor, but got a rank-${s.rank} tensor`), At(s, t, e);
 }
 const Mu = /* @__PURE__ */ C({ slice2d_: W0 });
@@ -6496,7 +6496,7 @@ const Mu = /* @__PURE__ */ C({ slice2d_: W0 });
  * =============================================================================
  */
 function G0(n, t, e) {
-  const s = I(n, "x", "slice3d");
+  const s = $(n, "x", "slice3d");
   return w(s.rank === 3, () => `slice3d expects a rank-3 tensor, but got a rank-${s.rank} tensor`), At(s, t, e);
 }
 const _i = /* @__PURE__ */ C({ slice3d_: G0 });
@@ -6517,7 +6517,7 @@ const _i = /* @__PURE__ */ C({ slice3d_: G0 });
  * =============================================================================
  */
 function V0(n, t = -1) {
-  const e = I(n, "logits", "softmax", "float32");
+  const e = $(n, "logits", "softmax", "float32");
   if (t === -1 && (t = e.rank - 1), t !== e.rank - 1)
     throw Error(`Softmax along a non-last dimension is not yet supported. Logits was rank ${e.rank} and dim was ${t}`);
   const s = { logits: e }, r = { dim: t };
@@ -6541,7 +6541,7 @@ const Bu = /* @__PURE__ */ C({ softmax_: V0 });
  * =============================================================================
  */
 function q0(n, t, e = 0) {
-  const r = { x: I(n, "x", "split") }, o = { numOrSizeSplits: t, axis: e };
+  const r = { x: $(n, "x", "split") }, o = { numOrSizeSplits: t, axis: e };
   return A.runKernel(Qd, r, o);
 }
 const Fu = /* @__PURE__ */ C({ split_: q0 });
@@ -6562,7 +6562,7 @@ const Fu = /* @__PURE__ */ C({ split_: q0 });
  * =============================================================================
  */
 function j0(n, t) {
-  const e = I(n, "x", "squeeze", "string_or_numeric");
+  const e = $(n, "x", "squeeze", "string_or_numeric");
   return L(e, Cf(e.shape, t).newShape);
 }
 const jr = /* @__PURE__ */ C({ squeeze_: j0 });
@@ -6606,7 +6606,7 @@ const br = /* @__PURE__ */ C({ stack_: H0 });
  * =============================================================================
  */
 function K0(n, t = 0) {
-  const s = { x: I(n, "x", "step") }, r = { alpha: t };
+  const s = { x: $(n, "x", "step") }, r = { alpha: t };
   return A.runKernel(ip, s, r);
 }
 const Y0 = /* @__PURE__ */ C({ step_: K0 });
@@ -6678,7 +6678,7 @@ const zu = /* @__PURE__ */ C({ truncatedNormal_: X0 });
  * =============================================================================
  */
 function J0(n, t = 0) {
-  const e = I(n, "x", "unstack", "string_or_numeric");
+  const e = $(n, "x", "unstack", "string_or_numeric");
   w(t >= -e.shape.length && t < e.shape.length, () => `Axis = ${t} is not in [-${e.shape.length}, ${e.shape.length})`);
   const s = { value: e }, r = { axis: t };
   return A.runKernel(rp, s, r);
@@ -6720,7 +6720,7 @@ function Z0(n, t = !0, e, s) {
  * =============================================================================
  */
 function Q0(n, t, e) {
-  const s = I(n, "x", "transpose");
+  const s = $(n, "x", "transpose");
   if (t == null && (t = s.shape.map((i, a) => a).reverse()), w(s.rank === t.length, () => `Error in transpose: rank of input ${s.rank} must match length of perm ${t}.`), t.forEach((i) => {
     w(i >= 0 && i < s.rank, () => `All entries in 'perm' must be between 0 and ${s.rank - 1} but got ${t}`);
   }), s.rank <= 1)
@@ -6827,14 +6827,14 @@ function ib({ x: n, filter: t, strides: e, pad: s, dataFormat: r = "NHWC", dilat
     let E = gi(n, t, e, s, r, o, i);
     return a != null && (E = M(E, a)), rb(E, l, u, c);
   }
-  const h = I(n, "x", "conv2d", "float32"), f = I(t, "filter", "conv2d", "float32");
+  const h = $(n, "x", "conv2d", "float32"), f = $(t, "filter", "conv2d", "float32");
   let d = h, p = !1;
   h.rank === 3 && (p = !0, d = L(h, [1, h.shape[0], h.shape[1], h.shape[2]])), w(d.rank === 4, () => `Error in fused conv2d: input must be rank 4, but got rank ${d.rank}.`), w(f.rank === 4, () => `Error in fused conv2d: filter must be rank 4, but got rank ${f.rank}.`), Te("fused conv2d", s, i);
   const g = r === "NHWC" ? d.shape[3] : d.shape[1];
   w(f.shape[2] === g, () => `Error in conv2d: depth of input (${g}) must match input depth for filter ${f.shape[2]}.`), w(Vn(e, o), () => `Error in conv2D: Either strides or dilations must be 1. Got strides ${e} and dilations '${o}'`);
   const m = di(d.shape, f.shape, e, o, s, i);
   let b;
-  a != null && (b = I(a, "bias", "fused conv2d"), [b] = Rt(b, h), r === "NHWC" ? Wt(m.outShape, b.shape) : (w(b.shape.length <= 1, () => `Error in fused conv2d: only supports scalar or 1-D Tensor bias for NCHW format but got the bias of rank-${b.shape.length}.`), w(b.shape.length === 0 || b.shape[0] === m.outChannels || b.shape[0] === 1, () => `Error in fused conv2d: bias shape (${b.shape}) is not compatible with the number of output channels (${m.outChannels})`)));
+  a != null && (b = $(a, "bias", "fused conv2d"), [b] = Rt(b, h), r === "NHWC" ? Wt(m.outShape, b.shape) : (w(b.shape.length <= 1, () => `Error in fused conv2d: only supports scalar or 1-D Tensor bias for NCHW format but got the bias of rank-${b.shape.length}.`), w(b.shape.length === 0 || b.shape[0] === m.outChannels || b.shape[0] === 1, () => `Error in fused conv2d: bias shape (${b.shape}) is not compatible with the number of output channels (${m.outChannels})`)));
   let y;
   if (u != null) {
     const E = u.shape;
@@ -6847,13 +6847,13 @@ function ib({ x: n, filter: t, strides: e, pad: s, dataFormat: r = "NHWC", dilat
         const k = `Error in fused conv2d: PReLU activation weights (${E}) is not compatible with the output shape of the conv2d (${m.outShape}).`;
         throw Error(k);
       }
-    y = I(u, "prelu weights", "fused conv2d");
+    y = $(u, "prelu weights", "fused conv2d");
   }
   const S = (E, D) => {
     w(r === "NHWC", () => `Error in gradient of fused conv2D: got dataFormat of ${r} but only NHWC is currently supported.`);
     const [k, T, R, B] = D, H = nb(E, R, l);
     w(Wo(o), () => `Error in gradient of fused conv2D: dilation rates greater than 1 are not yet supported in gradients. Got dilations '${o}'`);
-    const X = Iu(T.shape, H, k, e, s), W = eb(T, H, k.shape, e, s), U = [X, W];
+    const X = $u(T.shape, H, k, e, s), W = eb(T, H, k.shape, e, s), U = [X, W];
     if (B != null) {
       const j = sb(B, H);
       U.push(j);
@@ -6902,7 +6902,7 @@ const ab = /* @__PURE__ */ C({ fusedConv2d_: ib });
  * =============================================================================
  */
 function lb(n, t, e, s, r = "bilinear", o = 0) {
-  const i = I(n, "image", "cropAndResize"), a = I(t, "boxes", "cropAndResize", "float32"), l = I(e, "boxInd", "cropAndResize", "int32"), u = a.shape[0];
+  const i = $(n, "image", "cropAndResize"), a = $(t, "boxes", "cropAndResize", "float32"), l = $(e, "boxInd", "cropAndResize", "int32"), u = a.shape[0];
   w(i.rank === 4, () => `Error in cropAndResize: image must be rank 4,but got rank ${i.rank}.`), w(a.rank === 2 && a.shape[1] === 4, () => `Error in cropAndResize: boxes must be have size [${u},4] but had shape ${a.shape}.`), w(l.rank === 1 && l.shape[0] === u, () => `Error in cropAndResize: boxInd must be have size [${u}] but had shape ${a.shape}.`), w(s.length === 2, () => `Error in cropAndResize: cropSize must be of length 2, but got length ${s.length}.`), w(s[0] >= 1 && s[1] >= 1, () => `cropSize must be atleast [1,1], but was ${s}`), w(r === "bilinear" || r === "nearest", () => `method must be bilinear or nearest, but was ${r}`);
   const c = { image: i, boxes: a, boxInd: l }, h = { method: r, extrapolationValue: o, cropSize: s };
   return A.runKernel(td, c, h);
@@ -6925,7 +6925,7 @@ const ub = /* @__PURE__ */ C({ cropAndResize_: lb });
  * =============================================================================
  */
 function cb(n) {
-  const t = I(n, "image", "flipLeftRight", "float32");
+  const t = $(n, "image", "flipLeftRight", "float32");
   w(t.rank === 4, () => `Error in flipLeftRight: image must be rank 4,but got rank ${t.rank}.`);
   const e = { image: t };
   return A.runKernel(cd, e, {});
@@ -6948,7 +6948,7 @@ const hb = /* @__PURE__ */ C({ flipLeftRight_: cb });
  * =============================================================================
  */
 function fb(n) {
-  const t = I(n, "image", "grayscaleToRGB"), e = t.rank - 1, s = t.shape[e];
+  const t = $(n, "image", "grayscaleToRGB"), e = t.rank - 1, s = t.shape[e];
   w(t.rank >= 2, () => `Error in grayscaleToRGB: images must be at least rank 2, but got rank ${t.rank}.`), w(s === 1, () => `Error in grayscaleToRGB: last dimension of a grayscale image should be size 1, but got size ${s}.`);
   const r = new Array(t.rank);
   return r.fill(1, 0, e), r[e] = 3, rr(t, r);
@@ -6971,7 +6971,7 @@ const db = /* @__PURE__ */ C({ grayscaleToRGB_: fb });
  * =============================================================================
  */
 function pb(n) {
-  const t = I(n, "image", "RGBToGrayscale"), e = t.rank - 1, s = t.shape[e];
+  const t = $(n, "image", "RGBToGrayscale"), e = t.rank - 1, s = t.shape[e];
   w(t.rank >= 2, () => `Error in RGBToGrayscale: images must be at least rank 2, but got rank ${t.rank}.`), w(s === 3, () => `Error in RGBToGrayscale: last dimension of an RGB image should be size 3, but got size ${s}.`);
   const r = t.dtype, o = ot(t, "float32"), i = Dt([0.2989, 0.587, 0.114]);
   let a;
@@ -6994,7 +6994,7 @@ function pb(n) {
     default:
       throw new Error("Not a valid tensor rank.");
   }
-  return a = $e(a, -1), ot(a, r);
+  return a = Ie(a, -1), ot(a, r);
 }
 const mb = /* @__PURE__ */ C({ rgbToGrayscale_: pb });
 /**
@@ -7014,7 +7014,7 @@ const mb = /* @__PURE__ */ C({ rgbToGrayscale_: pb });
  * =============================================================================
  */
 function gb(n, t, e = 0, s = 0.5) {
-  const r = I(n, "image", "rotateWithOffset", "float32");
+  const r = $(n, "image", "rotateWithOffset", "float32");
   w(r.rank === 4, () => `Error in rotateWithOffset: image must be rank 4,but got rank ${r.rank}.`);
   const o = { image: r }, i = { radians: t, fillValue: e, center: s };
   return A.runKernel(ap, o, i);
@@ -7058,7 +7058,7 @@ function Hn(n, t, e, s, r, o) {
  * =============================================================================
  */
 function yb(n, t, e, s = 0.5, r = Number.NEGATIVE_INFINITY) {
-  const o = I(n, "boxes", "nonMaxSuppression", "float32"), i = I(t, "scores", "nonMaxSuppression", "float32"), a = Hn(o, i, e, s, r);
+  const o = $(n, "boxes", "nonMaxSuppression", "float32"), i = $(t, "scores", "nonMaxSuppression", "float32"), a = Hn(o, i, e, s, r);
   e = a.maxOutputSize, s = a.iouThreshold, r = a.scoreThreshold;
   const l = { maxOutputSize: e, iouThreshold: s, scoreThreshold: r };
   return A.runKernel(Dd, { boxes: o, scores: i }, l);
@@ -7112,7 +7112,7 @@ function vb(n, t, e) {
  * limitations under the License.
  * =============================================================================
  */
-function $b(n, t, e, s, r) {
+function Ib(n, t, e, s, r) {
   return Ci(
     n,
     t,
@@ -7123,7 +7123,7 @@ function $b(n, t, e, s, r) {
     /* softNmsSigma */
   );
 }
-function Ib(n, t, e, s, r, o) {
+function $b(n, t, e, s, r, o) {
   return Ci(
     n,
     t,
@@ -7207,9 +7207,9 @@ function La(n, t) {
  * =============================================================================
  */
 async function Cb(n, t, e, s = 0.5, r = Number.NEGATIVE_INFINITY) {
-  const o = I(n, "boxes", "nonMaxSuppressionAsync"), i = I(t, "scores", "nonMaxSuppressionAsync"), a = Hn(o, i, e, s, r);
+  const o = $(n, "boxes", "nonMaxSuppressionAsync"), i = $(t, "scores", "nonMaxSuppressionAsync"), a = Hn(o, i, e, s, r);
   e = a.maxOutputSize, s = a.iouThreshold, r = a.scoreThreshold;
-  const l = await Promise.all([o.data(), i.data()]), u = l[0], c = l[1], { selectedIndices: h } = $b(u, c, e, s, r);
+  const l = await Promise.all([o.data(), i.data()]), u = l[0], c = l[1], { selectedIndices: h } = Ib(u, c, e, s, r);
   return o !== n && o.dispose(), i !== t && i.dispose(), Dt(h, "int32");
 }
 const kb = Cb;
@@ -7230,7 +7230,7 @@ const kb = Cb;
  * =============================================================================
  */
 function Tb(n, t, e, s = 0.5, r = Number.NEGATIVE_INFINITY, o = 0) {
-  const i = I(n, "boxes", "nonMaxSuppression"), a = I(t, "scores", "nonMaxSuppression"), l = Hn(i, a, e, s, r, o);
+  const i = $(n, "boxes", "nonMaxSuppression"), a = $(t, "scores", "nonMaxSuppression"), l = Hn(i, a, e, s, r, o);
   e = l.maxOutputSize, s = l.iouThreshold, r = l.scoreThreshold, o = l.softNmsSigma;
   const u = { boxes: i, scores: a }, c = { maxOutputSize: e, iouThreshold: s, scoreThreshold: r, softNmsSigma: o }, h = A.runKernel(Rd, u, c);
   return { selectedIndices: h[0], selectedScores: h[1] };
@@ -7253,7 +7253,7 @@ const Nb = /* @__PURE__ */ C({ nonMaxSuppressionWithScore_: Tb });
  * =============================================================================
  */
 async function Db(n, t, e, s = 0.5, r = Number.NEGATIVE_INFINITY, o = 0) {
-  const i = I(n, "boxes", "nonMaxSuppressionAsync"), a = I(t, "scores", "nonMaxSuppressionAsync"), l = Hn(i, a, e, s, r, o);
+  const i = $(n, "boxes", "nonMaxSuppressionAsync"), a = $(t, "scores", "nonMaxSuppressionAsync"), l = Hn(i, a, e, s, r, o);
   e = l.maxOutputSize, s = l.iouThreshold, r = l.scoreThreshold, o = l.softNmsSigma;
   const u = await Promise.all([i.data(), a.data()]), c = u[0], h = u[1], { selectedIndices: f, selectedScores: d } = Ab(c, h, e, s, r, o);
   return i !== n && i.dispose(), a !== t && a.dispose(), {
@@ -7279,7 +7279,7 @@ const Pb = Db;
  * =============================================================================
  */
 function Rb(n, t, e, s = 0.5, r = Number.NEGATIVE_INFINITY, o = !1) {
-  const i = I(n, "boxes", "nonMaxSuppression"), a = I(t, "scores", "nonMaxSuppression"), l = Hn(
+  const i = $(n, "boxes", "nonMaxSuppression"), a = $(t, "scores", "nonMaxSuppression"), l = Hn(
     i,
     a,
     e,
@@ -7313,7 +7313,7 @@ const Lb = /* @__PURE__ */ C({ nonMaxSuppressionPadded_: Rb });
  * =============================================================================
  */
 async function Ob(n, t, e, s = 0.5, r = Number.NEGATIVE_INFINITY, o = !1) {
-  const i = I(n, "boxes", "nonMaxSuppressionAsync"), a = I(t, "scores", "nonMaxSuppressionAsync"), l = Hn(
+  const i = $(n, "boxes", "nonMaxSuppressionAsync"), a = $(t, "scores", "nonMaxSuppressionAsync"), l = Hn(
     i,
     a,
     e,
@@ -7321,7 +7321,7 @@ async function Ob(n, t, e, s = 0.5, r = Number.NEGATIVE_INFINITY, o = !1) {
     r,
     null
     /* softNmsSigma */
-  ), u = l.maxOutputSize, c = l.iouThreshold, h = l.scoreThreshold, [f, d] = await Promise.all([i.data(), a.data()]), { selectedIndices: p, validOutputs: g } = Ib(f, d, u, c, h, o);
+  ), u = l.maxOutputSize, c = l.iouThreshold, h = l.scoreThreshold, [f, d] = await Promise.all([i.data(), a.data()]), { selectedIndices: p, validOutputs: g } = $b(f, d, u, c, h, o);
   return i !== n && i.dispose(), a !== t && a.dispose(), {
     selectedIndices: Dt(p, "int32"),
     validOutputs: Yt(g, "int32")
@@ -7345,7 +7345,7 @@ const Mb = Ob;
  * =============================================================================
  */
 function Bb(n, t, e = !1, s = !1) {
-  const r = I(n, "images", "resizeBilinear");
+  const r = $(n, "images", "resizeBilinear");
   w(r.rank === 3 || r.rank === 4, () => `Error in resizeBilinear: x must be rank 3 or 4, but got rank ${r.rank}.`), w(t.length === 2, () => `Error in resizeBilinear: new shape must 2D, but got shape ${t}.`), w(s === !1 || e === !1, () => "Error in resizeBilinear: If halfPixelCenters is true, alignCorners must be false.");
   let o = r, i = !1;
   r.rank === 3 && (i = !0, o = L(r, [1, r.shape[0], r.shape[1], r.shape[2]]));
@@ -7370,7 +7370,7 @@ const Fb = /* @__PURE__ */ C({ resizeBilinear_: Bb });
  * =============================================================================
  */
 function zb(n, t, e = !1, s = !1) {
-  const r = I(n, "images", "resizeNearestNeighbor");
+  const r = $(n, "images", "resizeNearestNeighbor");
   w(r.rank === 3 || r.rank === 4, () => `Error in resizeNearestNeighbor: x must be rank 3 or 4, but got rank ${r.rank}.`), w(t.length === 2, () => `Error in resizeNearestNeighbor: new shape must 2D, but got shape ${t}.`), w(r.dtype === "float32" || r.dtype === "int32", () => "`images` must have `int32` or `float32` as dtype"), w(s === !1 || e === !1, () => "Error in resizeNearestNeighbor: If halfPixelCenters is true, alignCorners must be false.");
   let o = r, i = !1;
   r.rank === 3 && (i = !0, o = L(r, [1, r.shape[0], r.shape[1], r.shape[2]]));
@@ -7395,7 +7395,7 @@ const Ub = /* @__PURE__ */ C({ resizeNearestNeighbor_: zb });
  * =============================================================================
  */
 function Wb(n, t = "binary", e = !1, s = 0.5) {
-  const r = I(n, "image", "threshold"), o = 0.2989, i = 0.587, a = 0.114, l = r.shape[0] * r.shape[1];
+  const r = $(n, "image", "threshold"), o = 0.2989, i = 0.587, a = 0.114, l = r.shape[0] * r.shape[1];
   let u = N(Dt([s]), 255), c, h, f, d;
   if (w(r.rank === 3, () => `Error in threshold: image must be rank 3,but got rank ${r.rank}.`), w(r.shape[2] === 3 || r.shape[2] === 1, () => `Error in threshold: image color channel must be equal to 3 or 1but got ${r.shape[2]}.`), w(r.dtype === "int32" || r.dtype === "float32", () => `Error in dtype: image dtype must be int32 or float32,but got dtype ${r.dtype}.`), w(t === "otsu" || t === "binary", () => `Method must be binary or otsu, but was ${t}`), r.shape[2] === 3) {
     [c, h, f] = Fu(r, [1, 1, 1], -1);
@@ -7443,7 +7443,7 @@ const Vb = /* @__PURE__ */ C({ threshold_: Wb });
  * =============================================================================
  */
 function qb(n, t, e = "nearest", s = "constant", r = 0, o) {
-  const i = I(n, "image", "transform", "float32"), a = I(t, "transforms", "transform", "float32");
+  const i = $(n, "image", "transform", "float32"), a = $(t, "transforms", "transform", "float32");
   w(i.rank === 4, () => `Error in transform: image must be rank 4,but got rank ${i.rank}.`), w(a.rank === 2 && (a.shape[0] === i.shape[0] || a.shape[0] === 1) && a.shape[1] === 8, () => "Error in transform: Input transform should be batch x 8 or 1 x 8"), w(o == null || o.length === 2, () => `Error in transform: outputShape must be [height, width] or null, but got ${o}.`);
   const l = { image: i, transforms: a }, u = { interpolation: e, fillMode: s, fillValue: r, outputShape: o };
   return A.runKernel(sp, l, u);
@@ -7466,11 +7466,11 @@ const jb = /* @__PURE__ */ C({ transform_: qb });
  * =============================================================================
  */
 function Hb(n, t, e) {
-  const s = I(n, "a", "bandPart");
+  const s = $(n, "a", "bandPart");
   w(s.rank >= 2, () => `bandPart(): Rank must be at least 2, got ${s.rank}.`);
   const r = s.shape, [o, i] = s.shape.slice(-2);
   let a, l;
-  typeof t == "number" ? (w(t % 1 === 0, () => `bandPart(): numLower must be an integer, got ${t}.`), w(t <= o, () => `bandPart(): numLower (${t}) must not be greater than the number of rows (${o}).`), a = I(t < 0 ? o : t, "numLower", "bandPart")) : (w(t.dtype === "int32", () => "bandPart(): numLower's dtype must be an int32."), a = on(Ra(t, 0), o, mr(t, o))), typeof e == "number" ? (w(e % 1 === 0, () => `bandPart(): numUpper must be an integer, got ${e}.`), w(e <= i, () => `bandPart(): numUpper (${e}) must not be greater than the number of columns (${i}).`), l = I(e < 0 ? i : e, "numUpper", "bandPart")) : (w(e.dtype === "int32", () => "bandPart(): numUpper's dtype must be an int32."), l = on(Ra(e, 0), i, mr(e, i)));
+  typeof t == "number" ? (w(t % 1 === 0, () => `bandPart(): numLower must be an integer, got ${t}.`), w(t <= o, () => `bandPart(): numLower (${t}) must not be greater than the number of rows (${o}).`), a = $(t < 0 ? o : t, "numLower", "bandPart")) : (w(t.dtype === "int32", () => "bandPart(): numLower's dtype must be an int32."), a = on(Ra(t, 0), o, mr(t, o))), typeof e == "number" ? (w(e % 1 === 0, () => `bandPart(): numUpper must be an integer, got ${e}.`), w(e <= i, () => `bandPart(): numUpper (${e}) must not be greater than the number of columns (${i}).`), l = $(e < 0 ? i : e, "numUpper", "bandPart")) : (w(e.dtype === "int32", () => "bandPart(): numUpper's dtype must be an int32."), l = on(Ra(e, 0), i, mr(e, i)));
   const u = L(gr(0, o, 1, "int32"), [-1, 1]), c = gr(0, i, 1, "int32"), h = Z(u, c), f = qr(Nu(h, a), Lg(h, qn(l))), d = Fn([o, i], s.dtype);
   return L(br(Uu(L(s, [-1, o, i])).map((p) => on(f, p, d))), r);
 }
@@ -8564,7 +8564,7 @@ class ly {
  * limitations under the License.
  * =============================================================================
  */
-const $n = ly;
+const In = ly;
 /**
  * @license
  * Copyright 2017 Google LLC. All Rights Reserved.
@@ -8634,10 +8634,10 @@ function Ss(n, t) {
  * limitations under the License.
  * =============================================================================
  */
-var Ie;
+var $e;
 (function(n) {
   n[n.FIRST_DIM_SIZE = 0] = "FIRST_DIM_SIZE", n[n.VALUE_ROWIDS = 1] = "VALUE_ROWIDS", n[n.ROW_LENGTHS = 2] = "ROW_LENGTHS", n[n.ROW_SPLITS = 3] = "ROW_SPLITS", n[n.ROW_LIMITS = 4] = "ROW_LIMITS", n[n.ROW_STARTS = 5] = "ROW_STARTS";
-})(Ie || (Ie = {}));
+})($e || ($e = {}));
 function fy(n, t, e) {
   let s = new Array();
   if (e == null && t == null)
@@ -8664,12 +8664,12 @@ function fy(n, t, e) {
 }
 function dy(n) {
   const t = {
-    FIRST_DIM_SIZE: Ie.FIRST_DIM_SIZE,
-    VALUE_ROWIDS: Ie.VALUE_ROWIDS,
-    ROW_LENGTHS: Ie.ROW_LENGTHS,
-    ROW_SPLITS: Ie.ROW_SPLITS,
-    ROW_LIMITS: Ie.ROW_LIMITS,
-    ROW_STARTS: Ie.ROW_STARTS
+    FIRST_DIM_SIZE: $e.FIRST_DIM_SIZE,
+    VALUE_ROWIDS: $e.VALUE_ROWIDS,
+    ROW_LENGTHS: $e.ROW_LENGTHS,
+    ROW_SPLITS: $e.ROW_SPLITS,
+    ROW_LIMITS: $e.ROW_LIMITS,
+    ROW_STARTS: $e.ROW_STARTS
   }, e = [];
   for (const s of n)
     if (s in t)
@@ -8679,7 +8679,7 @@ function dy(n) {
   return e;
 }
 function py(n) {
-  return n.length === 0 ? 0 : n[0] === Ie.FIRST_DIM_SIZE ? n.length - 1 : n.length;
+  return n.length === 0 ? 0 : n[0] === $e.FIRST_DIM_SIZE ? n.length - 1 : n.length;
 }
 function my(n, t) {
   if (n == null || t == null)
@@ -8726,7 +8726,7 @@ const gy = 1.7580993408473768, by = 1.0507009873554805;
  * limitations under the License.
  * =============================================================================
  */
-const yy = 0.3275911, wy = 0.254829592, xy = -0.284496736, Sy = 1.421413741, vy = -1.453152027, $y = 1.061405429;
+const yy = 0.3275911, wy = 0.254829592, xy = -0.284496736, Sy = 1.421413741, vy = -1.453152027, Iy = 1.061405429;
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.
@@ -8767,7 +8767,7 @@ function Ma(n, t) {
  * limitations under the License.
  * =============================================================================
  */
-function Iy(n) {
+function $y(n) {
   return `Received SparseTensor with denseShape[0] = 0 but
   indices.shape[0] = ${n}`;
 }
@@ -8911,9 +8911,9 @@ class qe extends Error {
     super(t), Object.setPrototypeOf(this, qe.prototype);
   }
 }
-class $ extends Error {
+class I extends Error {
   constructor(t) {
-    super(t), Object.setPrototypeOf(this, $.prototype);
+    super(t), Object.setPrototypeOf(this, I.prototype);
   }
 }
 class J extends Error {
@@ -8997,19 +8997,19 @@ function Ns(n, t = {}, e = {}, s = "object", r = !1) {
     else if (o in Jt)
       i = Jt[o];
     else if (i = t[o], i == null)
-      throw new $(`Unknown ${s}: ${n}. This may be due to one of the following reasons:
+      throw new I(`Unknown ${s}: ${n}. This may be due to one of the following reasons:
 1. The ${s} is defined in Python, in which case it needs to be ported to TensorFlow.js or your JavaScript code.
 2. The custom ${s} is defined in JavaScript, but is not registered properly with tf.serialization.registerClass().`);
     return i;
   } else {
     const o = n;
     if (o.className == null || o.config == null)
-      throw new $(`${s}: Improper config format: ${JSON.stringify(o)}.
+      throw new I(`${s}: Improper config format: ${JSON.stringify(o)}.
 'className' and 'config' must set.`);
     const i = o.className;
     let a, l;
     if (i in e ? [a, l] = e[i] : i in Jt ? [a, l] = Jt.className : i in t && ([a, l] = t[i]), a == null)
-      throw new $(`Unknown ${s}: ${i}. This may be due to one of the following reasons:
+      throw new I(`Unknown ${s}: ${i}. This may be due to one of the following reasons:
 1. The ${s} is defined in Python, in which case it needs to be ported to TensorFlow.js or your JavaScript code.
 2. The custom ${s} is defined in JavaScript, but is not registered properly with tf.serialization.registerClass().`);
     if (l != null) {
@@ -9051,7 +9051,7 @@ function an(n) {
 }
 function Uy(n) {
   if (n == null)
-    throw new $(`Invalid value in obj: ${JSON.stringify(n)}`);
+    throw new I(`Invalid value in obj: ${JSON.stringify(n)}`);
   for (const t in n)
     if (n.hasOwnProperty(t))
       return !1;
@@ -9059,7 +9059,7 @@ function Uy(n) {
 }
 function Yn(n, t, e) {
   if (e != null && n.indexOf(e) < 0)
-    throw new $(`${e} is not a valid ${t}.  Valid values are ${n} or null/undefined.`);
+    throw new I(`${e} is not a valid ${t}.  Valid values are ${n} or null/undefined.`);
 }
 function Di(n, t, e = 0, s = 1 / 0) {
   return Ae(e >= 0), Ae(s >= e), Array.isArray(n) && n.length >= e && n.length <= s && n.every((r) => typeof r === t);
@@ -9089,7 +9089,7 @@ function Gy(n) {
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-const In = /* @__PURE__ */ new Map();
+const $n = /* @__PURE__ */ new Map();
 function gt(n) {
   Yn(Oy, "DataFormat", n);
 }
@@ -9123,11 +9123,11 @@ function Ju(n) {
 function Zu(n) {
   if (!Qu(n))
     throw new Error("Not a valid tensor name: '" + n + "'");
-  In.has(n) || In.set(n, 0);
-  const t = In.get(n);
-  if (In.set(n, In.get(n) + 1), t > 0) {
+  $n.has(n) || $n.set(n, 0);
+  const t = $n.get(n);
+  if ($n.set(n, $n.get(n) + 1), t > 0) {
     const e = `${n}_${t}`;
-    return In.set(e, 1), e;
+    return $n.set(e, 1), e;
   } else
     return n;
 }
@@ -9166,7 +9166,7 @@ function tc(n) {
 }
 function wr(n, t) {
   if (t < n)
-    throw new $(`end (${t}) < begin (${n}) is forbidden.`);
+    throw new I(`end (${t}) < begin (${n}) is forbidden.`);
   const e = [];
   for (let s = n; s < t; ++s)
     e.push(s);
@@ -9237,7 +9237,7 @@ function ln(n, t, e) {
           n.shape[5]
         ]);
       default:
-        throw new $(`sliceAlongFirstAxis() received an unsupported tensor rank: ${n.rank}`);
+        throw new I(`sliceAlongFirstAxis() received an unsupported tensor rank: ${n.rank}`);
     }
   });
 }
@@ -9253,7 +9253,7 @@ function po(n, t, e) {
       case 4:
         return ws(n, [0, 0, 0, t], [n.shape[0], n.shape[1], n.shape[2], e]);
       default:
-        throw new $(`sliceAlongLastAxis() received an unsupported tensor rank: ${n.rank}`);
+        throw new I(`sliceAlongLastAxis() received an unsupported tensor rank: ${n.rank}`);
     }
   });
 }
@@ -9269,7 +9269,7 @@ function Gs(n, t, e, s) {
           case 2:
             return po(n, t, e);
           default:
-            throw new $(`The axis is not within the rank of the tensor ${s}`);
+            throw new I(`The axis is not within the rank of the tensor ${s}`);
         }
       case 3:
         switch (s) {
@@ -9280,7 +9280,7 @@ function Gs(n, t, e, s) {
           case 3:
             return po(n, t, e);
           default:
-            throw new $(`The axis is not within the rank of the tensor ${s}`);
+            throw new I(`The axis is not within the rank of the tensor ${s}`);
         }
       case 4:
         switch (s) {
@@ -9293,10 +9293,10 @@ function Gs(n, t, e, s) {
           case 4:
             return po(n, t, e);
           default:
-            throw new $(`The axis is not within the rank of the tensor ${s}`);
+            throw new I(`The axis is not within the rank of the tensor ${s}`);
         }
       default:
-        throw new $(`sliceAlongLastAxis() received an unsupported tensor rank: ${n.rank}`);
+        throw new I(`sliceAlongLastAxis() received an unsupported tensor rank: ${n.rank}`);
     }
   });
 }
@@ -9316,7 +9316,7 @@ function Ds(n) {
 function Jy(n, t, e) {
   const s = t.shape;
   if (t.rank !== 1 && t.rank !== n)
-    throw new $(`Unexpected bias dimensions: ${t.rank}; expected it to be 1 or ${n}`);
+    throw new I(`Unexpected bias dimensions: ${t.rank}; expected it to be 1 or ${n}`);
   if (n === 5) {
     if (e === "channelsFirst")
       return s.length === 1 ? L(t, [1, s[0], 1, 1, 1]) : L(t, [1, s[3], s[0], s[1], s[2]]);
@@ -9334,7 +9334,7 @@ function Jy(n, t, e) {
       return s.length === 1 ? L(t, [1, 1, s[0]]) : L(t, [1].concat(s));
   } else if (n < 3)
     return t;
-  throw new $(`Unsupported input rank by biasAdd: ${t.rank}`);
+  throw new I(`Unsupported input rank by biasAdd: ${t.rank}`);
 }
 function Ps(n, t, e) {
   return _(() => (e == null && (e = Xn()), gt(e), M(n, Jy(n.rank, t, e))));
@@ -9659,7 +9659,7 @@ function Sr(n) {
  * =============================================================================
  */
 let sw = 0;
-function $c() {
+function Ic() {
   return sw++;
 }
 const Vs = {};
@@ -9699,13 +9699,13 @@ class Ne extends Kn {
     return {};
   }
 }
-class Ic extends Ne {
+class $c extends Ne {
   apply(t, e) {
     return Fn(t, e);
   }
 }
-Ic.className = "Zeros";
-O(Ic);
+$c.className = "Zeros";
+O($c);
 class Ac extends Ne {
   apply(t, e) {
     return wi(t, e);
@@ -9716,9 +9716,9 @@ O(Ac);
 class Ec extends Ne {
   constructor(t) {
     if (super(), typeof t != "object")
-      throw new $(`Expected argument of type ConstantConfig but got ${t}`);
+      throw new I(`Expected argument of type ConstantConfig but got ${t}`);
     if (t.value === void 0)
-      throw new $(`config must have value set but got ${t}`);
+      throw new I(`config must have value set but got ${t}`);
     this.value = t.value;
   }
   apply(t, e) {
@@ -9782,7 +9782,7 @@ class Tc extends Ne {
   apply(t, e) {
     return _(() => {
       if (t.length !== 2 || t[0] !== t[1])
-        throw new $("Identity matrix initializer can only be used for 2D square matrices.");
+        throw new I("Identity matrix initializer can only be used for 2D square matrices.");
       return N(this.gain, Tu(t[0]));
     });
   }
@@ -9817,7 +9817,7 @@ class Gt extends Ne {
    */
   constructor(t) {
     if (super(), t.scale < 0)
-      throw new $(`scale must be a positive float. Got: ${t.scale}`);
+      throw new I(`scale must be a positive float. Got: ${t.scale}`);
     this.scale = t.scale == null ? 1 : t.scale, this.mode = t.mode == null ? "fanIn" : t.mode, iw(this.mode), this.distribution = t.distribution == null ? "normal" : t.distribution, aw(this.distribution), this.seed = t.seed;
   }
   apply(t, e) {
@@ -10029,14 +10029,14 @@ function vs(n) {
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-function $r(n) {
+function Ir(n) {
   return n.length === 0 ? [] : Array.isArray(n[0]) ? n : [n];
 }
 function Vt(n) {
   let t;
   if (Array.isArray(n)) {
     if (n.length !== 1)
-      throw new $(`Expected Tensor length to be 1; got ${n.length}`);
+      throw new I(`Expected Tensor length to be 1; got ${n.length}`);
     t = n[0];
   } else
     t = n;
@@ -10046,7 +10046,7 @@ function ge(n) {
   if (Array.isArray(n) && Array.isArray(n[0])) {
     if (n.length === 1)
       return n = n, n[0];
-    throw new $(`Expected exactly 1 Shape; got ${n.length}`);
+    throw new I(`Expected exactly 1 Shape; got ${n.length}`);
   } else
     return n;
 }
@@ -10059,7 +10059,7 @@ function ge(n) {
  * https://opensource.org/licenses/MIT.
  * =============================================================================
  */
-function Ir(n) {
+function $r(n) {
   let t = 0;
   for (const e of n)
     e.shape.length === 0 ? t += 1 : t += e.shape.reduce((s, r) => s * r);
@@ -10091,7 +10091,7 @@ class uw {
    * @throws ValueError if `name` is `null` or `undefined`.
    */
   constructor(t, e = "float32", s = qa, r = !0, o = null) {
-    this.dtype = e ?? "float32", this.shape = t.shape, this.id = $c(), s = s ?? qa, this.originalName = Ju(s), this.name = Zu(this.originalName), this.trainable_ = r, this.constraint = o, this.val = Z0(t, this.trainable_, this.name, this.dtype);
+    this.dtype = e ?? "float32", this.shape = t.shape, this.id = Ic(), s = s ?? qa, this.originalName = Ju(s), this.name = Zu(this.originalName), this.trainable_ = r, this.constraint = o, this.val = Z0(t, this.trainable_, this.name, this.dtype);
   }
   /**
    * Get a snapshot of the Variable's value.
@@ -10171,7 +10171,7 @@ class bn {
    *   returned by apply().
    */
   constructor(t, e, s, r, o, i, a) {
-    this.dtype = t, this.shape = e, this.sourceLayer = s, this.inputs = r, this.callArgs = o, this.outputTensorIndex = a, this.id = $c(), i != null && (this.originalName = Ju(i), this.name = Zu(this.originalName)), this.rank = e.length;
+    this.dtype = t, this.shape = e, this.sourceLayer = s, this.inputs = r, this.callArgs = o, this.outputTensorIndex = a, this.id = Ic(), i != null && (this.originalName = Ju(i), this.name = Zu(this.originalName)), this.rank = e.length;
   }
 }
 let hw = 0;
@@ -10240,7 +10240,7 @@ class ye extends Kn {
     if (this.inboundNodes.length === 0)
       throw new qe(`The layer has never been called and thus has no defined ${e}.`);
     if (this.inboundNodes.length <= t)
-      throw new $(`Asked to get ${e} at node ${t}, but the layer has only ${this.inboundNodes.length} inbound nodes.`);
+      throw new I(`Asked to get ${e} at node ${t}, but the layer has only ${this.inboundNodes.length} inbound nodes.`);
     return this.inboundNodes[t];
   }
   /**
@@ -10381,33 +10381,33 @@ class ye extends Kn {
       return;
     const s = st(this.inputSpec);
     if (e.length !== s.length)
-      throw new $(`Layer ${this.name} expects ${s.length} inputs, but it received ${e.length} input tensors. Input received: ${t}`);
+      throw new I(`Layer ${this.name} expects ${s.length} inputs, but it received ${e.length} input tensors. Input received: ${t}`);
     for (let r = 0; r < e.length; r++) {
       const o = e[r], i = s[r];
       if (i == null)
         continue;
       const a = o.rank;
       if (i.ndim != null && a !== i.ndim)
-        throw new $(`Input ${r} is incompatible with layer ${this.name}: expected ndim=${i.ndim}, found ndim=${a}`);
+        throw new I(`Input ${r} is incompatible with layer ${this.name}: expected ndim=${i.ndim}, found ndim=${a}`);
       if (i.maxNDim != null && a > i.maxNDim)
-        throw new $(`Input ${r} is incompatible with layer ${this.name}: expected max_ndim=${i.maxNDim}, found ndim=${a}`);
+        throw new I(`Input ${r} is incompatible with layer ${this.name}: expected max_ndim=${i.maxNDim}, found ndim=${a}`);
       if (i.minNDim != null && a < i.minNDim)
-        throw new $(`Input ${r} is incompatible with layer ${this.name}: expected min_ndim=${i.minNDim}, found ndim=${a}.`);
+        throw new I(`Input ${r} is incompatible with layer ${this.name}: expected min_ndim=${i.minNDim}, found ndim=${a}.`);
       if (i.dtype != null && o.dtype !== i.dtype)
-        throw new $(`Input ${r} is incompatible with layer ${this.name} : expected dtype=${i.dtype}, found dtype=${o.dtype}.`);
+        throw new I(`Input ${r} is incompatible with layer ${this.name} : expected dtype=${i.dtype}, found dtype=${o.dtype}.`);
       if (i.axes) {
         const l = o.shape;
         for (const u in i.axes) {
           const c = Number(u), h = i.axes[u], f = c >= 0 ? l[c] : l[l.length + c];
           if (h != null && [h, null].indexOf(f) === -1)
-            throw new $(`Input ${r} is incompatible with layer ${this.name}: expected axis ${c} of input shape to have value ${h} but got shape ${l}.`);
+            throw new I(`Input ${r} is incompatible with layer ${this.name}: expected axis ${c} of input shape to have value ${h} but got shape ${l}.`);
         }
       }
       if (i.shape != null)
         for (let l = 0; l < i.shape.length; ++l) {
           const u = i.shape[l], c = o.shape[l];
           if (u != null && c != null && u !== c)
-            throw new $(`Input ${r} is incompatible with layer ${this.name}: expected shape=${i.shape}, found shape=${o.shape}.`);
+            throw new I(`Input ${r} is incompatible with layer ${this.name}: expected shape=${i.shape}, found shape=${o.shape}.`);
         }
     }
   }
@@ -10513,7 +10513,7 @@ class ye extends Kn {
     e = e || {}, this.assertNotDisposed();
     const s = st(t), r = mw(t), o = gw(t);
     if (r === o)
-      throw new $("Arguments to apply() must be all SymbolicTensors or all Tensors");
+      throw new I("Arguments to apply() must be all SymbolicTensors or all Tensors");
     return or(this.name, () => {
       if (!this.built) {
         this.assertInputCompatibility(t);
@@ -10598,7 +10598,7 @@ class ye extends Kn {
   countParams() {
     if (!this.built)
       throw new qe(`You tried to call countParams() on ${this.name}, but the layer is not built yet. Build it first by calling build(batchInputShape).`);
-    return Ir(this.weights);
+    return $r(this.weights);
   }
   /**
    * Creates the layer weights.
@@ -10641,14 +10641,14 @@ class ye extends Kn {
     _(() => {
       const e = this.weights;
       if (e.length !== t.length)
-        throw new $(`You called setWeights(weights) on layer "${this.name}" with a weight list of length ${t.length}, but the layer was expecting ${e.length} weights. Provided weights: ${t}...`);
+        throw new I(`You called setWeights(weights) on layer "${this.name}" with a weight list of length ${t.length}, but the layer was expecting ${e.length} weights. Provided weights: ${t}...`);
       if (e.length === 0)
         return;
       const s = [], r = ja(e);
       for (let o = 0; o < r.length; ++o) {
         const i = r[o], a = e[o], l = t[o];
         if (!oe(i.shape, l.shape))
-          throw new $(`Layer weight shape ${i.shape} not compatible with provided weight shape ${l.shape}`);
+          throw new I(`Layer weight shape ${i.shape} not compatible with provided weight shape ${l.shape}`);
         s.push([a, l]);
       }
       Dc(s);
@@ -10671,7 +10671,7 @@ class ye extends Kn {
    */
   addWeight(t, e, s, r, o, i, a, l) {
     if (this._addedWeightNames.indexOf(t) !== -1)
-      throw new $(`Duplicate weight name ${t} for layer ${this.name}`);
+      throw new I(`Duplicate weight name ${t} for layer ${this.name}`);
     this._addedWeightNames.push(t), s == null && (s = "float32"), this.fastWeightInitDuringBuild && (r = l != null ? l() : vs("zeros"));
     const u = r.apply(e, s), c = new uw(u, s, t, i, a);
     return u.dispose(), o != null && this.addLoss(() => o.apply(c.read())), i == null && (i = !0), i ? this._trainableWeights.push(c) : this._nonTrainableWeights.push(c), c;
@@ -10760,7 +10760,7 @@ class ye extends Kn {
    */
   addInboundNode(t, e, s, r, o, i, a = null) {
     const l = st(t);
-    e = st(e), s = st(s), r = st(r), o = $r(o), i = $r(i);
+    e = st(e), s = st(s), r = st(r), o = Ir(o), i = Ir(i);
     const u = [], c = [], h = [];
     for (const f of l)
       u.push(f.sourceLayer), c.push(f.nodeIndex), h.push(f.tensorIndex);
@@ -10926,13 +10926,13 @@ O(Rc);
 const Ha = {
   l1l2: "L1L2"
 };
-function $s(n) {
+function Is(n) {
   return Ni(n);
 }
 function Ka(n, t = {}) {
   return Ns(n, te.getMap().classNameMap, t, "regularizer");
 }
-function Is(n) {
+function $s(n) {
   if (n == null)
     return null;
   if (typeof n == "string") {
@@ -10953,11 +10953,11 @@ function go(n, t, e) {
   if (typeof n == "number")
     return yr(n, t);
   if (n.length !== t)
-    throw new $(`The ${e} argument must be an integer or tuple of ${t} integers. Received: ${n.length} elements.`);
+    throw new I(`The ${e} argument must be an integer or tuple of ${t} integers. Received: ${n.length} elements.`);
   for (let s = 0; s < t; ++s) {
     const r = n[s];
     if (!Hy(r))
-      throw new $(`The ${e} argument must be an integer or tuple of ${t} integers. Received: ${JSON.stringify(n)} including a non-integer number ${r}`);
+      throw new I(`The ${e} argument must be an integer or tuple of ${t} integers. Received: ${JSON.stringify(n)} including a non-integer number ${r}`);
   }
   return n;
 }
@@ -10976,7 +10976,7 @@ function Ee(n, t, e, s) {
   else if (s === "same")
     n = n * t;
   else
-    throw new $(`Unsupport padding mode: ${s}.`);
+    throw new I(`Unsupport padding mode: ${s}.`);
   return n;
 }
 /**
@@ -10997,11 +10997,11 @@ function Oc(n, t) {
 function yw(n, t, e, s = 1, r = "valid", o, i = 1) {
   return _(() => {
     if (o == null && (o = Xn()), gt(o), n.shape.length !== 3)
-      throw new $(`The input of a conv1dWithBias operation should be 3, but is ${n.shape.length} instead.`);
+      throw new I(`The input of a conv1dWithBias operation should be 3, but is ${n.shape.length} instead.`);
     if (t.shape.length !== 3)
-      throw new $(`The kernel for a conv1dWithBias operation should be 3, but is ${t.shape.length} instead`);
+      throw new I(`The kernel for a conv1dWithBias operation should be 3, but is ${t.shape.length} instead`);
     if (e != null && e.shape.length !== 1)
-      throw new $(`The bias for a conv1dWithBias operation should be 1, but is ${e.shape.length} instead`);
+      throw new I(`The bias for a conv1dWithBias operation should be 1, but is ${e.shape.length} instead`);
     if (o === "channelsFirst" && (n = pt(n, [0, 2, 1])), r === "causal")
       throw new J("The support for CAUSAL padding mode in conv1dWithBias is not implemented yet.");
     let a = Km(n, t, s, r === "same" ? "same" : "valid", "NWC", i);
@@ -11011,9 +11011,9 @@ function yw(n, t, e, s = 1, r = "valid", o, i = 1) {
 function Ya(n, t, e, s = [1, 1], r = "valid", o, i, a = null) {
   return _(() => {
     if (o == null && (o = Xn()), gt(o), n.rank !== 3 && n.rank !== 4)
-      throw new $(`conv2dWithBiasActivation expects input to be of rank 3 or 4, but received ${n.rank}.`);
+      throw new I(`conv2dWithBiasActivation expects input to be of rank 3 or 4, but received ${n.rank}.`);
     if (t.rank !== 3 && t.rank !== 4)
-      throw new $(`conv2dWithBiasActivation expects kernel to be of rank 3 or 4, but received ${n.rank}.`);
+      throw new I(`conv2dWithBiasActivation expects kernel to be of rank 3 or 4, but received ${n.rank}.`);
     let l = Lc(n, o);
     if (r === "causal")
       throw new J("The support for CAUSAL padding mode in conv1dWithBias is not implemented yet.");
@@ -11032,9 +11032,9 @@ function Ya(n, t, e, s = [1, 1], r = "valid", o, i, a = null) {
 function ww(n, t, e, s = [1, 1, 1], r = "valid", o, i) {
   return _(() => {
     if (o == null && (o = Xn()), gt(o), n.rank !== 4 && n.rank !== 5)
-      throw new $(`conv3dWithBias expects input to be of rank 4 or 5, but received ${n.rank}.`);
+      throw new I(`conv3dWithBias expects input to be of rank 4 or 5, but received ${n.rank}.`);
     if (t.rank !== 4 && t.rank !== 5)
-      throw new $(`conv3dWithBias expects kernel to be of rank 4 or 5, but received ${n.rank}.`);
+      throw new I(`conv3dWithBias expects kernel to be of rank 4 or 5, but received ${n.rank}.`);
     let a = Oc(n, o);
     if (r === "causal")
       throw new J("The support for CAUSAL padding mode in conv3dWithBias is not implemented yet.");
@@ -11045,23 +11045,23 @@ class Gi extends ye {
   constructor(t, e) {
     if (super(e), this.bias = null, this.DEFAULT_KERNEL_INITIALIZER = "glorotNormal", this.DEFAULT_BIAS_INITIALIZER = "zeros", Gi.verifyArgs(e), this.rank = t, Oe(this.rank, "rank"), this.rank !== 1 && this.rank !== 2 && this.rank !== 3)
       throw new J(`Convolution layer for rank other than 1, 2, or 3 (${this.rank}) is not implemented yet.`);
-    if (this.kernelSize = go(e.kernelSize, t, "kernelSize"), this.strides = go(e.strides == null ? 1 : e.strides, t, "strides"), this.padding = e.padding == null ? "valid" : e.padding, ie(this.padding), this.dataFormat = e.dataFormat == null ? "channelsLast" : e.dataFormat, gt(this.dataFormat), this.activation = nw(e.activation), this.useBias = e.useBias == null ? !0 : e.useBias, this.biasInitializer = vs(e.biasInitializer || this.DEFAULT_BIAS_INITIALIZER), this.biasConstraint = Sr(e.biasConstraint), this.biasRegularizer = Is(e.biasRegularizer), this.activityRegularizer = Is(e.activityRegularizer), this.dilationRate = go(e.dilationRate == null ? 1 : e.dilationRate, t, "dilationRate"), this.rank === 1 && Array.isArray(this.dilationRate) && this.dilationRate.length !== 1)
-      throw new $(`dilationRate must be a number or an array of a single number for 1D convolution, but received ${JSON.stringify(this.dilationRate)}`);
+    if (this.kernelSize = go(e.kernelSize, t, "kernelSize"), this.strides = go(e.strides == null ? 1 : e.strides, t, "strides"), this.padding = e.padding == null ? "valid" : e.padding, ie(this.padding), this.dataFormat = e.dataFormat == null ? "channelsLast" : e.dataFormat, gt(this.dataFormat), this.activation = nw(e.activation), this.useBias = e.useBias == null ? !0 : e.useBias, this.biasInitializer = vs(e.biasInitializer || this.DEFAULT_BIAS_INITIALIZER), this.biasConstraint = Sr(e.biasConstraint), this.biasRegularizer = $s(e.biasRegularizer), this.activityRegularizer = $s(e.activityRegularizer), this.dilationRate = go(e.dilationRate == null ? 1 : e.dilationRate, t, "dilationRate"), this.rank === 1 && Array.isArray(this.dilationRate) && this.dilationRate.length !== 1)
+      throw new I(`dilationRate must be a number or an array of a single number for 1D convolution, but received ${JSON.stringify(this.dilationRate)}`);
     if (this.rank === 2) {
       if (typeof this.dilationRate == "number")
         this.dilationRate = [this.dilationRate, this.dilationRate];
       else if (this.dilationRate.length !== 2)
-        throw new $(`dilationRate must be a number or array of two numbers for 2D convolution, but received ${JSON.stringify(this.dilationRate)}`);
+        throw new I(`dilationRate must be a number or array of two numbers for 2D convolution, but received ${JSON.stringify(this.dilationRate)}`);
     } else if (this.rank === 3) {
       if (typeof this.dilationRate == "number")
         this.dilationRate = [this.dilationRate, this.dilationRate, this.dilationRate];
       else if (this.dilationRate.length !== 3)
-        throw new $(`dilationRate must be a number or array of three numbers for 3D convolution, but received ${JSON.stringify(this.dilationRate)}`);
+        throw new I(`dilationRate must be a number or array of three numbers for 3D convolution, but received ${JSON.stringify(this.dilationRate)}`);
     }
   }
   static verifyArgs(t) {
     if (Ae("kernelSize" in t, "required key 'kernelSize' not in config"), typeof t.kernelSize != "number" && !Di(t.kernelSize, "number", 1, 3))
-      throw new $(`BaseConv expects config.kernelSize to be number or number[] with length 1, 2, or 3, but received ${JSON.stringify(t.kernelSize)}.`);
+      throw new I(`BaseConv expects config.kernelSize to be number or number[] with length 1, 2, or 3, but received ${JSON.stringify(t.kernelSize)}.`);
   }
   getConfig() {
     const t = {
@@ -11073,8 +11073,8 @@ class Gi extends ye {
       activation: ew(this.activation),
       useBias: this.useBias,
       biasInitializer: vr(this.biasInitializer),
-      biasRegularizer: $s(this.biasRegularizer),
-      activityRegularizer: $s(this.activityRegularizer),
+      biasRegularizer: Is(this.biasRegularizer),
+      activityRegularizer: Is(this.activityRegularizer),
       biasConstraint: xr(this.biasConstraint)
     }, e = super.getConfig();
     return Object.assign(t, e), t;
@@ -11082,13 +11082,13 @@ class Gi extends ye {
 }
 class Jn extends Gi {
   constructor(t, e) {
-    super(t, e), this.kernel = null, Jn.verifyArgs(e), this.filters = e.filters, Oe(this.filters, "filters"), this.kernelInitializer = vs(e.kernelInitializer || this.DEFAULT_KERNEL_INITIALIZER), this.kernelConstraint = Sr(e.kernelConstraint), this.kernelRegularizer = Is(e.kernelRegularizer);
+    super(t, e), this.kernel = null, Jn.verifyArgs(e), this.filters = e.filters, Oe(this.filters, "filters"), this.kernelInitializer = vs(e.kernelInitializer || this.DEFAULT_KERNEL_INITIALIZER), this.kernelConstraint = Sr(e.kernelConstraint), this.kernelRegularizer = $s(e.kernelRegularizer);
   }
   build(t) {
     t = ge(t);
     const e = this.dataFormat === "channelsFirst" ? 1 : t.length - 1;
     if (t[e] == null)
-      throw new $(`The channel dimension of the input should be defined. Found ${t[e]}`);
+      throw new I(`The channel dimension of the input should be defined. Found ${t[e]}`);
     const s = t[e], r = this.kernelSize.concat([s, this.filters]);
     this.kernel = this.addWeight("kernel", r, null, this.kernelInitializer, this.kernelRegularizer, !0, this.kernelConstraint), this.useBias && (this.bias = this.addWeight("bias", [this.filters], null, this.biasInitializer, this.biasRegularizer, !0, this.biasConstraint)), this.inputSpec = [{ ndim: this.rank + 2, axes: { [e]: s } }], this.built = !0;
   }
@@ -11127,14 +11127,14 @@ class Jn extends Gi {
     const t = {
       filters: this.filters,
       kernelInitializer: vr(this.kernelInitializer),
-      kernelRegularizer: $s(this.kernelRegularizer),
+      kernelRegularizer: Is(this.kernelRegularizer),
       kernelConstraint: xr(this.kernelConstraint)
     }, e = super.getConfig();
     return Object.assign(t, e), t;
   }
   static verifyArgs(t) {
     if (!("filters" in t) || typeof t.filters != "number" || t.filters < 1)
-      throw new $(`Convolution layer expected config.filters to be a 'number' > 0 but got ${JSON.stringify(t.filters)}`);
+      throw new I(`Convolution layer expected config.filters to be a 'number' > 0 but got ${JSON.stringify(t.filters)}`);
   }
 }
 class Zn extends Jn {
@@ -11147,7 +11147,7 @@ class Zn extends Jn {
   }
   static verifyArgs(t) {
     if (typeof t.kernelSize != "number" && !Di(t.kernelSize, "number", 1, 2))
-      throw new $(`Conv2D expects config.kernelSize to be number or number[] with length 1 or 2, but received ${JSON.stringify(t.kernelSize)}.`);
+      throw new I(`Conv2D expects config.kernelSize to be number or number[] with length 1 or 2, but received ${JSON.stringify(t.kernelSize)}.`);
   }
 }
 Zn.className = "Conv2D";
@@ -11162,7 +11162,7 @@ class Ls extends Jn {
   }
   static verifyArgs(t) {
     if (typeof t.kernelSize != "number" && !(Array.isArray(t.kernelSize) && (t.kernelSize.length === 1 || t.kernelSize.length === 3)))
-      throw new $(`Conv3D expects config.kernelSize to be number or [number, number, number], but received ${JSON.stringify(t.kernelSize)}.`);
+      throw new I(`Conv3D expects config.kernelSize to be number or [number, number, number], but received ${JSON.stringify(t.kernelSize)}.`);
   }
 }
 Ls.className = "Conv3D";
@@ -11170,14 +11170,14 @@ O(Ls);
 class Mc extends Zn {
   constructor(t) {
     if (super(t), this.inputSpec = [new Ce({ ndim: 4 })], this.padding !== "same" && this.padding !== "valid")
-      throw new $(`Conv2DTranspose currently supports only padding modes 'same' and 'valid', but received padding mode ${this.padding}`);
+      throw new I(`Conv2DTranspose currently supports only padding modes 'same' and 'valid', but received padding mode ${this.padding}`);
   }
   build(t) {
     if (t = ge(t), t.length !== 4)
-      throw new $("Input should have rank 4; Received input shape: " + JSON.stringify(t));
+      throw new I("Input should have rank 4; Received input shape: " + JSON.stringify(t));
     const e = this.dataFormat === "channelsFirst" ? 1 : t.length - 1;
     if (t[e] == null)
-      throw new $("The channel dimension of the inputs should be defined. Found `None`.");
+      throw new I("The channel dimension of the inputs should be defined. Found `None`.");
     const s = t[e], r = this.kernelSize.concat([this.filters, s]);
     this.kernel = this.addWeight("kernel", r, "float32", this.kernelInitializer, this.kernelRegularizer, !0, this.kernelConstraint), this.useBias && (this.bias = this.addWeight("bias", [this.filters], "float32", this.biasInitializer, this.biasRegularizer, !0, this.biasConstraint)), this.inputSpec = [new Ce({ ndim: 4, axes: { [e]: s } })], this.built = !0;
   }
@@ -11185,7 +11185,7 @@ class Mc extends Zn {
     return _(() => {
       let s = Vt(t);
       if (s.shape.length !== 4)
-        throw new $(`Conv2DTranspose.call() expects input tensor to be rank-4, but received a tensor of rank-${s.shape.length}`);
+        throw new I(`Conv2DTranspose.call() expects input tensor to be rank-4, but received a tensor of rank-${s.shape.length}`);
       const r = s.shape, o = r[0];
       let i, a;
       this.dataFormat === "channelsFirst" ? (i = 2, a = 3) : (i = 1, a = 2);
@@ -11213,14 +11213,14 @@ O(Mc);
 class Bc extends Ls {
   constructor(t) {
     if (super(t), this.inputSpec = [new Ce({ ndim: 5 })], this.padding !== "same" && this.padding !== "valid")
-      throw new $(`Conv3DTranspose currently supports only padding modes 'same' and 'valid', but received padding mode ${this.padding}`);
+      throw new I(`Conv3DTranspose currently supports only padding modes 'same' and 'valid', but received padding mode ${this.padding}`);
   }
   build(t) {
     if (t = ge(t), t.length !== 5)
-      throw new $("Input should have rank 5; Received input shape: " + JSON.stringify(t));
+      throw new I("Input should have rank 5; Received input shape: " + JSON.stringify(t));
     const e = this.dataFormat === "channelsFirst" ? 1 : t.length - 1;
     if (t[e] == null)
-      throw new $("The channel dimension of the inputs should be defined. Found `None`.");
+      throw new I("The channel dimension of the inputs should be defined. Found `None`.");
     const s = t[e], r = this.kernelSize.concat([this.filters, s]);
     this.kernel = this.addWeight("kernel", r, "float32", this.kernelInitializer, this.kernelRegularizer, !0, this.kernelConstraint), this.useBias && (this.bias = this.addWeight("bias", [this.filters], "float32", this.biasInitializer, this.biasRegularizer, !0, this.biasConstraint)), this.inputSpec = [new Ce({ ndim: 5, axes: { [e]: s } })], this.built = !0;
   }
@@ -11228,7 +11228,7 @@ class Bc extends Ls {
     return _(() => {
       let s = Vt(t);
       if (s.shape.length !== 5)
-        throw new $(`Conv3DTranspose.call() expects input tensor to be rank-4, but received a tensor of rank-${s.shape.length}`);
+        throw new I(`Conv3DTranspose.call() expects input tensor to be rank-4, but received a tensor of rank-${s.shape.length}`);
       const r = s.shape, o = r[0];
       let i, a, l;
       this.dataFormat === "channelsFirst" ? (l = 2, i = 3, a = 4) : (l = 1, i = 2, a = 3);
@@ -11256,19 +11256,19 @@ O(Bc);
 class Fc extends Jn {
   constructor(t, e) {
     if (super(t, e), this.DEFAULT_DEPTHWISE_INITIALIZER = "glorotUniform", this.DEFAULT_POINTWISE_INITIALIZER = "glorotUniform", this.depthwiseKernel = null, this.pointwiseKernel = null, e.filters == null)
-      throw new $("The `filters` configuration field is required by SeparableConv, but is unspecified.");
+      throw new I("The `filters` configuration field is required by SeparableConv, but is unspecified.");
     if (e.kernelInitializer != null || e.kernelRegularizer != null || e.kernelConstraint != null)
-      throw new $("Fields kernelInitializer, kernelRegularizer and kernelConstraint are invalid for SeparableConv2D. Use depthwiseInitializer, depthwiseRegularizer, depthwiseConstraint, pointwiseInitializer, pointwiseRegularizer and pointwiseConstraint instead.");
+      throw new I("Fields kernelInitializer, kernelRegularizer and kernelConstraint are invalid for SeparableConv2D. Use depthwiseInitializer, depthwiseRegularizer, depthwiseConstraint, pointwiseInitializer, pointwiseRegularizer and pointwiseConstraint instead.");
     if (e.padding != null && e.padding !== "same" && e.padding !== "valid")
-      throw new $(`SeparableConv${this.rank}D supports only padding modes: 'same' and 'valid', but received ${JSON.stringify(e.padding)}`);
-    this.depthMultiplier = e.depthMultiplier == null ? 1 : e.depthMultiplier, this.depthwiseInitializer = vs(e.depthwiseInitializer || this.DEFAULT_DEPTHWISE_INITIALIZER), this.depthwiseRegularizer = Is(e.depthwiseRegularizer), this.depthwiseConstraint = Sr(e.depthwiseConstraint), this.pointwiseInitializer = vs(e.depthwiseInitializer || this.DEFAULT_POINTWISE_INITIALIZER), this.pointwiseRegularizer = Is(e.pointwiseRegularizer), this.pointwiseConstraint = Sr(e.pointwiseConstraint);
+      throw new I(`SeparableConv${this.rank}D supports only padding modes: 'same' and 'valid', but received ${JSON.stringify(e.padding)}`);
+    this.depthMultiplier = e.depthMultiplier == null ? 1 : e.depthMultiplier, this.depthwiseInitializer = vs(e.depthwiseInitializer || this.DEFAULT_DEPTHWISE_INITIALIZER), this.depthwiseRegularizer = $s(e.depthwiseRegularizer), this.depthwiseConstraint = Sr(e.depthwiseConstraint), this.pointwiseInitializer = vs(e.depthwiseInitializer || this.DEFAULT_POINTWISE_INITIALIZER), this.pointwiseRegularizer = $s(e.pointwiseRegularizer), this.pointwiseConstraint = Sr(e.pointwiseConstraint);
   }
   build(t) {
     if (t = ge(t), t.length < this.rank + 2)
-      throw new $(`Inputs to SeparableConv${this.rank}D should have rank ${this.rank + 2}, but received input shape: ${JSON.stringify(t)}`);
+      throw new I(`Inputs to SeparableConv${this.rank}D should have rank ${this.rank + 2}, but received input shape: ${JSON.stringify(t)}`);
     const e = this.dataFormat === "channelsFirst" ? 1 : t.length - 1;
     if (t[e] == null || t[e] < 0)
-      throw new $(`The channel dimension of the inputs should be defined, but found ${JSON.stringify(t[e])}`);
+      throw new I(`The channel dimension of the inputs should be defined, but found ${JSON.stringify(t[e])}`);
     const s = t[e], r = this.kernelSize.concat([s, this.depthMultiplier]), o = [];
     for (let a = 0; a < this.rank; ++a)
       o.push(1);
@@ -11287,7 +11287,7 @@ class Fc extends Jn {
   }
   getConfig() {
     const t = super.getConfig();
-    return delete t.rank, delete t.kernelInitializer, delete t.kernelRegularizer, delete t.kernelConstraint, t.depthwiseInitializer = vr(this.depthwiseInitializer), t.pointwiseInitializer = vr(this.pointwiseInitializer), t.depthwiseRegularizer = $s(this.depthwiseRegularizer), t.pointwiseRegularizer = $s(this.pointwiseRegularizer), t.depthwiseConstraint = xr(this.depthwiseConstraint), t.pointwiseConstraint = xr(this.pointwiseConstraint), t;
+    return delete t.rank, delete t.kernelInitializer, delete t.kernelRegularizer, delete t.kernelConstraint, t.depthwiseInitializer = vr(this.depthwiseInitializer), t.pointwiseInitializer = vr(this.pointwiseInitializer), t.depthwiseRegularizer = Is(this.depthwiseRegularizer), t.pointwiseRegularizer = Is(this.pointwiseRegularizer), t.depthwiseConstraint = xr(this.depthwiseConstraint), t.pointwiseConstraint = xr(this.pointwiseConstraint), t;
   }
 }
 Fc.className = "SeparableConv";
@@ -11308,7 +11308,7 @@ class Hr extends Jn {
   }
   static verifyArgs(t) {
     if (typeof t.kernelSize != "number" && !Di(t.kernelSize, "number", 1, 1))
-      throw new $(`Conv1D expects config.kernelSize to be number or number[] with length 1, but received ${JSON.stringify(t.kernelSize)}.`);
+      throw new I(`Conv1D expects config.kernelSize to be number or number[] with length 1, but received ${JSON.stringify(t.kernelSize)}.`);
   }
 }
 Hr.className = "Conv1D";
@@ -11433,7 +11433,7 @@ class Gc extends ye {
     else if (Array.isArray(t.poolSize) && t.poolSize.length === 1 && typeof t.poolSize[0] == "number")
       this.poolSize = t.poolSize;
     else
-      throw new $(`poolSize for 1D convolutional layer must be a number or an Array of a single number, but received ${JSON.stringify(t.poolSize)}`);
+      throw new I(`poolSize for 1D convolutional layer must be a number or an Array of a single number, but received ${JSON.stringify(t.poolSize)}`);
     if (Oe(this.poolSize, "poolSize"), t.strides == null)
       this.strides = this.poolSize;
     else if (typeof t.strides == "number")
@@ -11441,7 +11441,7 @@ class Gc extends ye {
     else if (Array.isArray(t.strides) && t.strides.length === 1 && typeof t.strides[0] == "number")
       this.strides = t.strides;
     else
-      throw new $(`strides for 1D convolutional layer must be a number or an Array of a single number, but received ${JSON.stringify(t.strides)}`);
+      throw new I(`strides for 1D convolutional layer must be a number or an Array of a single number, but received ${JSON.stringify(t.strides)}`);
     Oe(this.strides, "strides"), this.padding = t.padding == null ? "valid" : t.padding, ie(this.padding), this.inputSpec = [new Ce({ ndim: 3 })];
   }
   computeOutputShape(t) {
@@ -11491,7 +11491,7 @@ class jc extends ye {
       this.strides = this.poolSize;
     else if (Array.isArray(t.strides)) {
       if (t.strides.length !== 2)
-        throw new $(`If the strides property of a 2D pooling layer is an Array, it is expected to have a length of 2, but received length ${t.strides.length}.`);
+        throw new I(`If the strides property of a 2D pooling layer is an Array, it is expected to have a length of 2, but received length ${t.strides.length}.`);
       this.strides = t.strides;
     } else
       this.strides = [t.strides, t.strides];
@@ -11541,7 +11541,7 @@ class Kc extends ye {
       this.strides = this.poolSize;
     else if (Array.isArray(t.strides)) {
       if (t.strides.length !== 3)
-        throw new $(`If the strides property of a 3D pooling layer is an Array, it is expected to have a length of 3, but received length ${t.strides.length}.`);
+        throw new I(`If the strides property of a 3D pooling layer is an Array, it is expected to have a length of 3, but received length ${t.strides.length}.`);
       this.strides = t.strides;
     } else
       this.strides = [t.strides, t.strides, t.strides];
@@ -11703,13 +11703,13 @@ function vw(n, t) {
     return St(e, -1);
   });
 }
-function $w(n, t) {
+function Iw(n, t) {
   return _(() => {
     const e = et(N(n, t), -1), s = Ge(N(Z(1, n), t), -1);
     return jn(0, M(1, Z(s, e)));
   });
 }
-function Iw(n, t) {
+function $w(n, t) {
   return _(() => {
     const e = Math.log(2), s = Z(t, n), r = Z(M(s, yi(N(-2, s))), e);
     return St(r, -1);
@@ -11736,7 +11736,7 @@ function Er(n, t, e = !1) {
 }
 function Aw(n, t) {
   if (!oe(n.shape, t.shape))
-    throw new $(`logits and labels must have the same shape, but got shapes ${JSON.stringify(n.shape)} and ${JSON.stringify(t.shape)}`);
+    throw new I(`logits and labels must have the same shape, but got shapes ${JSON.stringify(n.shape)} and ${JSON.stringify(t.shape)}`);
   return _(() => {
     const e = Ts(t), s = qn(Nt(t));
     return M(Z(e, N(t, n)), Vg(Go(s)));
@@ -11773,8 +11773,8 @@ const _r = {
   meanSquaredLogarithmicError: xw,
   squaredHinge: Sw,
   hinge: vw,
-  categoricalHinge: $w,
-  logcosh: Iw,
+  categoricalHinge: Iw,
+  logcosh: $w,
   categoricalCrossentropy: As,
   sparseCategoricalCrossentropy: Er,
   binaryCrossentropy: Xr,
@@ -11787,7 +11787,7 @@ function bo(n) {
     if (n in _r)
       return _r[n];
     let t = `Unknown loss ${n}`;
-    throw n.toLowerCase().includes("softmaxcrossentropy") && (t = `Unknown loss ${n}. Use "categoricalCrossentropy" as the string name for tf.losses.softmaxCrossEntropy`), new $(t);
+    throw n.toLowerCase().includes("softmaxcrossentropy") && (t = `Unknown loss ${n}. Use "categoricalCrossentropy" as the string name for tf.losses.softmaxCrossEntropy`), new I(t);
   } else
     return n;
 }
@@ -11839,7 +11839,7 @@ class vn extends ye {
         s.push(o);
       else {
         if (o !== i)
-          throw new $("Operands could not be broadcast together with shapes " + JSON.stringify(t) + " " + JSON.stringify(e));
+          throw new I("Operands could not be broadcast together with shapes " + JSON.stringify(t) + " " + JSON.stringify(e));
         s.push(o);
       }
     }
@@ -11847,12 +11847,12 @@ class vn extends ye {
   }
   build(t) {
     if (Array.isArray(t) && !Array.isArray(t[0]) && (t = [ge(t)]), t = t, t.length < 2)
-      throw new $(`A merge layer should be called on an Array of at least 2 inputs. Got ${t.length} input(s).`);
+      throw new I(`A merge layer should be called on an Array of at least 2 inputs. Got ${t.length} input(s).`);
     let e = [];
     for (const o of t)
       o != null && o[0] !== null && e.push(o[0]);
     if (e = an(e), e.length > 1)
-      throw new $(`Can not merge tensors with different batch sizes. Got tensors with shapes: ${JSON.stringify(t)}.`);
+      throw new I(`Can not merge tensors with different batch sizes. Got tensors with shapes: ${JSON.stringify(t)}.`);
     let s = t[0] == null ? null : t[0].slice(1);
     for (let o = 1; o < t.length; ++o) {
       const i = t[o] == null ? null : t[o].slice(1);
@@ -11923,14 +11923,14 @@ class vn extends ye {
       if (e == null)
         return null;
       if (!Array.isArray(e))
-        throw new $("`mask` should be an Array");
+        throw new I("`mask` should be an Array");
       if (!Array.isArray(t))
-        throw new $("`inputs` should be an Array");
+        throw new I("`inputs` should be an Array");
       if (e.length !== t.length)
-        throw new $(`The Array 'inputs' and 'mask' are expected to have the same length, but have different lengths (${t.length} vs ${e.length})`);
+        throw new I(`The Array 'inputs' and 'mask' are expected to have the same length, but have different lengths (${t.length} vs ${e.length})`);
       if (e.every((r) => r == null))
         return null;
-      e = e.map((r) => r == null ? r : $e(r, 0));
+      e = e.map((r) => r == null ? r : Ie(r, 0));
       let s = e[0];
       for (let r = 1; r < e.length - 1; ++r)
         s = qr(s, e[r]);
@@ -12019,7 +12019,7 @@ class Ki extends vn {
   }
   build(t) {
     if (!(Array.isArray(t) && Array.isArray(t[0])) || t.length === 1)
-      throw new $("A `Concatenate` layer should be called on a list of at least 2 inputs");
+      throw new I("A `Concatenate` layer should be called on a list of at least 2 inputs");
     t = t;
     let e = !0;
     for (const r of t)
@@ -12042,14 +12042,14 @@ class Ki extends vn {
       i || s.push(o);
     }
     if (s.length > 1)
-      throw new $("A `Concatenate` layer requires inputs with matching shapes except for the concat axis. Got input shapes: " + JSON.stringify(t));
+      throw new I("A `Concatenate` layer requires inputs with matching shapes except for the concat axis. Got input shapes: " + JSON.stringify(t));
   }
   mergeFunction(t) {
     return _(() => Yy(t, this.axis));
   }
   computeOutputShape(t) {
     if (!(Array.isArray(t) && Array.isArray(t[0])))
-      throw new $("A `Concatenate` layer should be called on a list of inputs.");
+      throw new I("A `Concatenate` layer should be called on a list of inputs.");
     const e = t, s = e[0].slice(), r = this.axis < 0 ? s.length + this.axis : this.axis;
     for (const o of e.slice(1)) {
       if (s[r] == null || o[r] == null) {
@@ -12064,11 +12064,11 @@ class Ki extends vn {
     if (e == null)
       return null;
     if (!Array.isArray(e))
-      throw new $("`mask` should be an array for Concatenate");
+      throw new I("`mask` should be an array for Concatenate");
     if (!Array.isArray(t))
-      throw new $("`inputs` should be an array for Concatenate");
+      throw new I("`inputs` should be an array for Concatenate");
     if (e.length !== t.length)
-      throw new $(`Mismatch in the length of mask (${e.length}) and the legnth of inputs (${t.length})`);
+      throw new I(`Mismatch in the length of mask (${e.length}) and the legnth of inputs (${t.length})`);
     return _(() => {
       let s = !0;
       if (e.forEach((i) => {
@@ -12080,7 +12080,7 @@ class Ki extends vn {
         return null;
       const r = [];
       for (let i = 0; i < t.length; ++i)
-        e[i] == null ? r.push(ot(Du(t[i]), "bool")) : e[i].rank < t[i].rank ? r.push($e(e[i], -1)) : r.push(e[i]);
+        e[i] == null ? r.push(ot(Du(t[i]), "bool")) : e[i].rank < t[i].rank ? r.push(Ie(e[i], -1)) : r.push(e[i]);
       const o = rn(r, this.axis);
       return _m(o, -1, !1);
     });
@@ -12138,7 +12138,7 @@ function Cw(n, t, e) {
         u.push(c);
       a = jr(a, u);
     }
-    return a.shape.length === 1 && (a = $e(a, 1)), a;
+    return a.shape.length === 1 && (a = Ie(a, 1)), a;
   });
 }
 class uh extends vn {
@@ -12152,11 +12152,11 @@ class uh extends vn {
       throw new J("Dot layer does not support tensors of 4D or higher rank yet.");
     const r = this.interpretAxes(e, s);
     if (e[r[0]] !== s[r[1]])
-      throw new $(`Dimension incompatibility: ${e[r[0]]} !== ${s[r[1]]}`);
+      throw new I(`Dimension incompatibility: ${e[r[0]]} !== ${s[r[1]]}`);
   }
   mergeFunction(t) {
     if (t.length !== 2)
-      throw new $(`A \`Dot\` layer must be called on exactly 2 inputs, but received ${t.length} input(s).`);
+      throw new I(`A \`Dot\` layer must be called on exactly 2 inputs, but received ${t.length} input(s).`);
     let e = t[0], s = t[1], r;
     return Array.isArray(this.axes) ? r = this.axes.map((o, i) => os(o, t[i].shape.length)) : r = [
       os(this.axes, e.shape.length),
@@ -12473,7 +12473,7 @@ class Qt {
     for (const e in Qt.constructors)
       Qt.constructors[+e].forEach((r) => {
         if (r === t)
-          throw new $("Duplicate callback constructor.");
+          throw new I("Duplicate callback constructor.");
       });
   }
   /**
@@ -12585,7 +12585,7 @@ function jw(n) {
     return Cr[n];
   if (typeof n != "string" && n != null)
     return n;
-  throw new $(`Unknown metric ${n}`);
+  throw new I(`Unknown metric ${n}`);
 }
 function qs(n) {
   if (Ae(n !== null, `Unknown LossOrMetricFn ${n}`), typeof n == "string")
@@ -12618,16 +12618,16 @@ function qs(n) {
  */
 function Hw(n) {
   const t = {
-    Adagrad: () => $n.adagrad(0.01),
-    Adadelta: () => $n.adadelta(1, 0.95, mt()),
-    Adam: () => $n.adam(1e-3, 0.9, 0.999, mt()),
-    Adamax: () => $n.adamax(2e-3, 0.9, 0.999, mt(), 0),
-    RMSProp: () => $n.rmsprop(1e-3, 0.9, 0, mt()),
-    SGD: () => $n.sgd(0.01)
+    Adagrad: () => In.adagrad(0.01),
+    Adadelta: () => In.adadelta(1, 0.95, mt()),
+    Adam: () => In.adam(1e-3, 0.9, 0.999, mt()),
+    Adamax: () => In.adamax(2e-3, 0.9, 0.999, mt(), 0),
+    RMSProp: () => In.rmsprop(1e-3, 0.9, 0, mt()),
+    SGD: () => In.sgd(0.01)
   };
   if (t.adagrad = t.Adagrad, t.adadelta = t.Adadelta, t.adam = t.Adam, t.adamax = t.Adamax, t.rmsprop = t.RMSProp, t.sgd = t.SGD, n in t)
     return t[n]();
-  throw new $(`Unknown Optimizer ${n}`);
+  throw new I(`Unknown Optimizer ${n}`);
 }
 /**
  * @license
@@ -12692,12 +12692,12 @@ function Kw(n, t, e, s = console.log) {
   for (let c = 0; c < a.length; ++c)
     r ? Jw(a[c], e, s) : Zw(a[c], e, i, s), s((c === a.length - 1 ? "=" : "_").repeat(t));
   n.checkTrainableWeightsConsistency();
-  const l = Yw(n), u = Ir(n.nonTrainableWeights);
+  const l = Yw(n), u = $r(n.nonTrainableWeights);
   s(`Total params: ${l + u}`), s(`Trainable params: ${l}`), s(`Non-trainable params: ${u}`), s("_".repeat(t));
 }
 function Yw(n) {
   let t;
-  return n.collectedTrainableWeights != null ? t = Ir(n.collectedTrainableWeights) : t = Ir(n.trainableWeights), t;
+  return n.collectedTrainableWeights != null ? t = $r(n.collectedTrainableWeights) : t = $r(n.trainableWeights), t;
 }
 function Xw(n) {
   let t = !0;
@@ -12846,7 +12846,7 @@ function Ko(n, t) {
   }
 }
 /** @license See the LICENSE file. */
-const wh = "4.22.0";
+const wh = "4.20.0";
 /**
  * @license
  * Copyright 2022 Google LLC
@@ -12916,14 +12916,14 @@ class Os extends ye {
       dtype: t.dtype,
       name: t.name != null ? t.name : Li("input").toString()
     }), t.batchSize == null && (t.batchSize = null), t.sparse == null && (t.sparse = !1), this.trainable = !1, this.built = !0, this.sparse = t.sparse, t.inputShape != null && t.batchInputShape != null)
-      throw new $("Only provide the inputShape OR batchInputShape argument to inputLayer, not both at the same time.");
+      throw new I("Only provide the inputShape OR batchInputShape argument to inputLayer, not both at the same time.");
     let e = t.batchInputShape;
     if (e == null) {
       if (t.inputShape == null)
-        throw new $("An InputLayer should be passed either a `batchInputShape` or an `inputShape`.");
+        throw new I("An InputLayer should be passed either a `batchInputShape` or an `inputShape`.");
       e = [t.batchSize].concat(t.inputShape);
     } else if (t.batchSize != null)
-      throw new $("Cannot specify batchSize if batchInputShape is specified when creating an InputLayer.");
+      throw new I("Cannot specify batchSize if batchInputShape is specified when creating an InputLayer.");
     const s = t.dtype || "float32";
     this.batchInputShape = e, this.dtype = s, this.inputSpec = [{ shape: e }];
     const r = new bn(this.dtype, this.batchInputShape, this, [], {}, this.name);
@@ -12941,7 +12941,7 @@ class Os extends ye {
     });
   }
   apply(t, e) {
-    throw new $(`Cannot pass any input to an InputLayer's apply() method. InputLayer name: ${this.name}`);
+    throw new I(`Cannot pass any input to an InputLayer's apply() method. InputLayer name: ${this.name}`);
   }
   dispose() {
     return { refCountAfterDispose: this._refCount, numDisposedVariables: 0 };
@@ -12961,7 +12961,7 @@ function Qw(n) {
   if (n.batchShape == null && n.shape == null)
     throw new Error("Please provide to Input either a `shape` or a `batchShape` argument. Note that `shape` does not include the batch dimension.");
   if (n.batchShape != null && n.shape != null)
-    throw new $("Please provide either a `shape` or `batchShape` argument to Input, but not both.");
+    throw new I("Please provide either a `shape` or `batchShape` argument to Input, but not both.");
   let t = n.batchShape;
   n.shape != null && t == null && (t = [null].concat(n.shape));
   let e = n.dtype;
@@ -12987,7 +12987,7 @@ function t1(n, t) {
   try {
     return ot(t, n.dtype);
   } catch {
-    throw new $(`The dtype of the feed (${t.dtype}) can not be cast to the dtype of the key '${n.name}' (${n.dtype}).`);
+    throw new I(`The dtype of the feed (${t.dtype}) can not be cast to the dtype of the key '${n.name}' (${n.dtype}).`);
   }
 }
 class Ue {
@@ -13021,7 +13021,7 @@ class Ue {
     if (this.id2Value[t.id] == null)
       this.id2Value[t.id] = t1(t, e), this.name2Id[t.name] = t.id, s != null && (this.id2Mask[t.id] = s);
     else
-      throw new $(`Duplicate key: name=${t.name}, id=${t.id}`);
+      throw new I(`Duplicate key: name=${t.name}, id=${t.id}`);
     return this;
   }
   /**
@@ -13055,12 +13055,12 @@ class Ue {
   getValue(t) {
     if (t instanceof bn) {
       if (this.id2Value[t.id] == null)
-        throw new $(`Nonexistent key: ${t.name}`);
+        throw new I(`Nonexistent key: ${t.name}`);
       return this.id2Value[t.id];
     } else {
       const e = this.name2Id[t];
       if (e == null)
-        throw new $(`Feed dict has no SymbolicTensor name: ${t}`);
+        throw new I(`Feed dict has no SymbolicTensor name: ${t}`);
       return this.id2Value[e];
     }
   }
@@ -13074,12 +13074,12 @@ class Ue {
   getMask(t) {
     if (t instanceof bn) {
       if (this.id2Value[t.id] == null)
-        throw new $(`Nonexistent key: ${t.name}`);
+        throw new I(`Nonexistent key: ${t.name}`);
       return this.id2Mask[t.id];
     } else {
       const e = this.name2Id[t];
       if (e == null)
-        throw new $(`Feed dict has no SymbolicTensor name: ${t}`);
+        throw new I(`Feed dict has no SymbolicTensor name: ${t}`);
       return this.id2Mask[e];
     }
   }
@@ -13213,7 +13213,7 @@ class fe extends ye {
       this.name = Li(y);
     }
     if (this.supportsMasking = !1, this.trainable_ = !0, Array.isArray(t.inputs) ? this.inputs = t.inputs.slice() : this.inputs = [t.inputs], Array.isArray(t.outputs) ? this.outputs = t.outputs.slice() : this.outputs = [t.outputs], an(this.inputs).length !== this.inputs.length)
-      throw new $(`The list of inputs passed to the model is redundant. All inputs should only appear once. Found: ${this.inputs.map((y) => y.name)}`);
+      throw new I(`The list of inputs passed to the model is redundant. All inputs should only appear once. Found: ${this.inputs.map((y) => y.name)}`);
     an(this.outputs).length !== this.outputs.length && console.warn(`The list of outputs passed to the model is redundant. All outputs should only appear once. Found: ${this.outputs.map((y) => y.name)}`), this.inputLayers = [], this.inputLayersNodeIndices = [], this.inputLayersTensorIndices = [], this.outputLayers = [], this.outputLayersNodeIndices = [], this.outputLayersTensorIndices = [], this.layers = [], this.internalContainerRefs = [];
     for (const y of this.outputs) {
       const S = y.sourceLayer, x = y.nodeIndex, v = y.tensorIndex;
@@ -13369,7 +13369,7 @@ class fe extends ye {
   }
   get trainableWeights() {
     if (this._trainableWeights.length > 0)
-      throw new $("Container instance unexpectedly contains _trainableWeights.The trainable weights of a Container are a union of the trainable weights of its consituent Layers. Its own _trainableWeights must remain an empty Array.");
+      throw new I("Container instance unexpectedly contains _trainableWeights.The trainable weights of a Container are a union of the trainable weights of its consituent Layers. Its own _trainableWeights must remain an empty Array.");
     if (!this.trainable)
       return [];
     let t = [];
@@ -13416,7 +13416,7 @@ class fe extends ye {
       for (const [l, u] of a.weights.entries()) {
         const c = o ? `${u.name.split("/").slice(0, -1).join("/") + "/"}${l}` : u.originalName;
         if (s[c] != null)
-          throw new $(`Duplicate weight name: ${c}`);
+          throw new I(`Duplicate weight name: ${c}`);
         s[c] = u, r++;
       }
     const i = [];
@@ -13429,7 +13429,7 @@ class fe extends ye {
       if (s[l] != null)
         i.push([s[l], t[a]]);
       else if (e)
-        throw new $(`Provided weight data has no target variable: ${a}`);
+        throw new I(`Provided weight data has no target variable: ${a}`);
       delete s[l];
     }
     if (e) {
@@ -13437,7 +13437,7 @@ class fe extends ye {
       for (const l in s)
         a.push(l);
       if (a.length > 0)
-        throw new $(`${a.length} of ${r} weights are not set: ${a}`);
+        throw new I(`${a.length} of ${r} weights are not set: ${a}`);
     }
     Dc(i);
   }
@@ -13519,9 +13519,9 @@ class fe extends ye {
    *   free dimensions, instead of an integer.
    */
   computeOutputShape(t) {
-    const e = $r(t);
+    const e = Ir(t);
     if (e.length !== this.inputLayers.length)
-      throw new $(`Invalid inputShape argument ${t}: model has ${this.inputLayers.length} tensor inputs.`);
+      throw new I(`Invalid inputShape argument ${t}: model has ${this.inputLayers.length} tensor inputs.`);
     const s = {};
     for (let a = 0; a < e.length; a++) {
       const l = this.inputLayers[a], u = e[a], c = l.name + "_0_0";
@@ -13540,7 +13540,7 @@ class fe extends ye {
             const m = u.inboundLayers[g], b = u.nodeIndices[g], y = u.tensorIndices[g], S = `${m.name}_${b}_${y}`, x = s[S];
             h.push(x);
           }
-          const f = c.computeOutputShape(zt(h)), d = $r(f), p = c.inboundNodes.indexOf(u);
+          const f = c.computeOutputShape(zt(h)), d = Ir(f), p = c.inboundNodes.indexOf(u);
           for (let g = 0; g < d.length; g++) {
             const m = `${c.name}_${p}_${g}`;
             s[m] = d[g];
@@ -13630,17 +13630,17 @@ class fe extends ye {
     if (e != null)
       return this.findLayer(e);
     if (t == null)
-      throw new $("Provide either a layer name or layer index");
+      throw new I("Provide either a layer name or layer index");
     if (typeof t == "number")
       return this.findLayer(t);
     for (const s of this.layers)
       if (s.name === t)
         return s;
-    throw new $(`No such layer: ${t}`);
+    throw new I(`No such layer: ${t}`);
   }
   findLayer(t) {
     if (this.layers.length <= t)
-      throw new $(`Was asked to retrieve layer at index ${t}, but model only has ${this.layers.length} layer(s).`);
+      throw new I(`Was asked to retrieve layer at index ${t}, but model only has ${this.layers.length} layer(s).`);
     return this.layers[t];
   }
   /**
@@ -13752,7 +13752,7 @@ class fe extends ye {
       const b = m.name, y = dh(m, e.customObjects != null ? e.customObjects : {});
       y.setFastWeightInitDuringBuild(r), o[b] = y, m.inboundNodes.forEach((x) => {
         if (!(x instanceof Array))
-          throw new $(`Corrupted configuration, expected array for nodeData: ${x}`);
+          throw new I(`Corrupted configuration, expected array for nodeData: ${x}`);
         a(y, x);
       });
     }
@@ -13793,7 +13793,7 @@ class fe extends ye {
    */
   get stateful() {
     if (this._stateful)
-      throw new $("Container instance unexpectedly has _stateful = true. The statefulness of a Container is determined by the Layers it contains. Its _stateful property must remain the default false.");
+      throw new I("Container instance unexpectedly has _stateful = true. The statefulness of a Container is determined by the Layers it contains. Its _stateful property must remain the default false.");
     for (const t of this.layers)
       if (t.stateful)
         return !0;
@@ -13880,7 +13880,7 @@ function i1(n, t) {
  * =============================================================================
  */
 const a1 = 32;
-function $h(n, t) {
+function Ih(n, t) {
   let e, s;
   const r = t;
   e = r.xs, s = r.ys, w(e != null && s != null, () => `A Dataset iterator for fitDataset() is expected to generate objects of the form \`{xs: xVal, ys: yVal}\`, where the two values may be \`tf.Tensor\`, an array of Tensors, or a map of string to Tensor.  The provided Dataset instead generates ${t}`);
@@ -13901,7 +13901,7 @@ function nl(n, t, e) {
     const s = [];
     for (const r of t) {
       if (e[r] == null)
-        throw new $(`The feature data generated by the dataset lacks the required ${n} key '${r}'.`);
+        throw new I(`The feature data generated by the dataset lacks the required ${n} key '${r}'.`);
       s.push(e[r]);
     }
     return s;
@@ -13959,7 +13959,7 @@ async function u1(n, t, e) {
           break;
         }
         if (S.value != null) {
-          const { xs: x, ys: v } = $h(n, S.value), E = {};
+          const { xs: x, ys: v } = Ih(n, S.value), E = {};
           E.batch = y, E.size = x[0].shape[0], await f.onBatchBegin(y, E);
           const D = [];
           if (e.classWeight != null) {
@@ -14021,7 +14021,7 @@ async function f1(n, t, e) {
     const u = await i.next();
     if (o = _(() => {
       if (u.value) {
-        const { xs: c, ys: h } = $h(n, u.value), f = c.concat(h), d = _(() => r(f));
+        const { xs: c, ys: h } = Ih(n, u.value), f = c.concat(h), d = _(() => r(f));
         if (ut(f), l === 0)
           for (let g = 0; g < d.length; ++g)
             o.push(Yt(0));
@@ -14069,7 +14069,7 @@ function wo(n, t) {
     r = s + t, r >= n && (r = n), e.push([s, r]), s = r;
   return e;
 }
-function Ih(n) {
+function $h(n) {
   const t = [];
   n instanceof Et && (n = [n]);
   for (let e = 0; e < n.length; ++e) {
@@ -14146,7 +14146,7 @@ function ol(n, t, e, s = !0, r = "") {
       } else
         i = !0;
       if (i)
-        throw new $(`Error when checking model ${r} expected no data, but got ${n}`);
+        throw new I(`Error when checking model ${r} expected no data, but got ${n}`);
     }
     return [];
   }
@@ -14157,31 +14157,31 @@ function ol(n, t, e, s = !0, r = "") {
     n = n, o = [];
     for (const i of t) {
       if (n[i] == null)
-        throw new $(`No data provided for "${i}". Need data for each key in: ${t}`);
+        throw new I(`No data provided for "${i}". Need data for each key in: ${t}`);
       o.push(n[i]);
     }
   } else if (Xo(n)) {
     if (n = n, n.length !== t.length)
-      throw new $(`Error when checking model ${r}: the Array of Tensors that you are passing to your model is not the size the model expected. Expected to see ${t.length} Tensor(s), but instead got the following list of Tensor(s): ${n}`);
+      throw new I(`Error when checking model ${r}: the Array of Tensors that you are passing to your model is not the size the model expected. Expected to see ${t.length} Tensor(s), but instead got the following list of Tensor(s): ${n}`);
     o = n;
   } else {
     if (n = n, t.length > 1)
-      throw new $(`The model ${r} expects ${t.length} Tensor(s), but only received one Tensor. Found: Tensor with shape ${n.shape}`);
+      throw new I(`The model ${r} expects ${t.length} Tensor(s), but only received one Tensor. Found: Tensor with shape ${n.shape}`);
     o = [n];
   }
-  if (o = Ih(o), e != null)
+  if (o = $h(o), e != null)
     for (let i = 0; i < t.length; ++i) {
       if (e[i] == null)
         continue;
       const a = o[i];
       if (a.shape.length !== e[i].length)
-        throw new $(`Error when checking ${r}: expected ${t[i]} to have ${e[i].length} dimension(s). but got array with shape ${a.shape}`);
+        throw new I(`Error when checking ${r}: expected ${t[i]} to have ${e[i].length} dimension(s). but got array with shape ${a.shape}`);
       for (let l = 0; l < e[i].length; ++l) {
         if (l === 0 && !s)
           continue;
         const u = a.shape[l], c = e[i][l];
         if (c != null && c >= 0 && u !== c)
-          throw new $(`${r} expected a batch of elements where each example has shape [${e[i].slice(1, e[i].length)}] (i.e.,tensor shape [*,${e[i].slice(1, e[i].length)}]) but the ${r} received an input with ${a.shape[0]} examples, each with shape [${a.shape.slice(1, a.shape.length)}] (tensor shape [${a.shape}])`);
+          throw new I(`${r} expected a batch of elements where each example has shape [${e[i].slice(1, e[i].length)}] (i.e.,tensor shape [*,${e[i].slice(1, e[i].length)}]) but the ${r} received an input with ${a.shape[0]} examples, each with shape [${a.shape.slice(1, a.shape.length)}] (tensor shape [${a.shape}])`);
       }
     }
   return o;
@@ -14191,11 +14191,11 @@ function p1(n, t, e) {
   s.sort();
   const r = an(t.map((o) => o.shape[0]));
   if (r.sort(), s.length > 1)
-    throw new $(`All input Tensors (x) should have the same number of samples. Got array shapes: ${JSON.stringify(n.map((o) => o.shape))}`);
+    throw new I(`All input Tensors (x) should have the same number of samples. Got array shapes: ${JSON.stringify(n.map((o) => o.shape))}`);
   if (r.length > 1)
-    throw new $(`All target Tensors (y) should have the same number of samples. Got array shapes: ${JSON.stringify(t.map((o) => o.shape))}`);
+    throw new I(`All target Tensors (y) should have the same number of samples. Got array shapes: ${JSON.stringify(t.map((o) => o.shape))}`);
   if (s.length > 0 && r.length > 0 && !oe(s, r))
-    throw new $(`Input Tensors should have the same number of samples as target Tensors. Found ${s[0]} input sample(s) and ${r[0]} target sample(s).`);
+    throw new I(`Input Tensors should have the same number of samples as target Tensors. Found ${s[0]} input sample(s) and ${r[0]} target sample(s).`);
 }
 function m1(n, t, e) {
   const s = [
@@ -14207,13 +14207,13 @@ function m1(n, t, e) {
     const o = n[r], i = t[r], a = e[r];
     if (i != null) {
       if (i === As && o.shape[o.shape.length - 1] === 1)
-        throw new $(`You are passing a target array of shape ${o.shape} while using a loss 'categorical_crossentropy'. 'categorical_crossentropy'expects targets to be binary matrices (1s and 0s) of shape [samples, classes].`);
+        throw new I(`You are passing a target array of shape ${o.shape} while using a loss 'categorical_crossentropy'. 'categorical_crossentropy'expects targets to be binary matrices (1s and 0s) of shape [samples, classes].`);
       if (s.indexOf(i) !== -1) {
         const l = o.shape.slice(1), u = a.slice(1);
         for (let c = 0; c < l.length; ++c) {
           const h = l[c], f = u[c];
           if (f != null && h !== f)
-            throw new $(`A target Tensor with shape ${o.shape} was passed for an output of shape ${a}, while using a loss function that expects targets to have the same shape as the output.`);
+            throw new I(`A target Tensor with shape ${o.shape} was passed for an output of shape ${a}, while using a loss function that expects targets to have the same shape as the output.`);
         }
       }
     }
@@ -14223,11 +14223,11 @@ function il(n, t, e, s = !0, r = "") {
   let o;
   if (Array.isArray(n)) {
     if (n.length !== t.length)
-      throw new $(`Error when checking model ${r}: the Array of Tensors that you are passing to your model is not the size the the model expected. Expected to see ${t.length} Tensor(s), but instead got ${n.length} Tensors(s).`);
+      throw new I(`Error when checking model ${r}: the Array of Tensors that you are passing to your model is not the size the the model expected. Expected to see ${t.length} Tensor(s), but instead got ${n.length} Tensors(s).`);
     o = n;
   } else {
     if (t.length > 1)
-      throw new $(`The model expects ${t.length} ${r} Tensors, but only received one Tensor. Found: array with shape ${JSON.stringify(n.shape)}.`);
+      throw new I(`The model expects ${t.length} ${r} Tensors, but only received one Tensor. Found: array with shape ${JSON.stringify(n.shape)}.`);
     o = [n];
   }
   if (e != null)
@@ -14236,13 +14236,13 @@ function il(n, t, e, s = !0, r = "") {
         continue;
       const a = o[i];
       if (a.shape.length !== e[i].length)
-        throw new $(`Error when checking ${r}: expected ${t[i]} to have ${e[i].length} dimension(s), but got array with shape ${JSON.stringify(a.shape)}`);
+        throw new I(`Error when checking ${r}: expected ${t[i]} to have ${e[i].length} dimension(s), but got array with shape ${JSON.stringify(a.shape)}`);
       for (let l = 0; l < e[i].length; ++l) {
         if (l === 0 && !s)
           continue;
         const u = a.shape[l], c = e[i][l];
         if (c != null && c !== u)
-          throw new $(`Error when checking ${r}: expected ${t[i]} to have shape ${JSON.stringify(e[i])} but got array with shape ${JSON.stringify(a.shape)}.`);
+          throw new I(`Error when checking ${r}: expected ${t[i]} to have shape ${JSON.stringify(e[i])} but got array with shape ${JSON.stringify(a.shape)}.`);
       }
     }
 }
@@ -14309,7 +14309,7 @@ class Jr extends fe {
    */
   summary(t, e, s = console.log) {
     if (!this.built)
-      throw new $("This model has never been called, thus its weights have not been created yet. So no summary can be displayed. Build the model first (e.g., by calling it on some test data).");
+      throw new I("This model has never been called, thus its weights have not been created yet. So no summary can be displayed. Build the model first (e.g., by calling it on some test data).");
     Kw(this, t, e, s);
   }
   /**
@@ -14327,7 +14327,7 @@ class Jr extends fe {
       this.optimizer_ = Hw(t.optimizer), this.isOptimizerOwned = !0;
     else {
       if (!(t.optimizer instanceof Ke))
-        throw new $("User-defined optimizer must be an instance of tf.Optimizer.");
+        throw new I("User-defined optimizer must be an instance of tf.Optimizer.");
       this.optimizer_ = t.optimizer, this.isOptimizerOwned = !1;
     }
     let e = [];
@@ -14335,12 +14335,12 @@ class Jr extends fe {
       t.loss = t.loss;
       for (const i in t.loss)
         if (this.outputNames.indexOf(i) === -1)
-          throw new $(`Unknown entry in loss dictionary: "${i}". Only expected the following keys: ${this.outputNames}`);
+          throw new I(`Unknown entry in loss dictionary: "${i}". Only expected the following keys: ${this.outputNames}`);
       for (const i of this.outputNames)
         t.loss[i] == null && console.warn(`Output "${i}" is missing from loss dictionary. We assume this was done on purpose, and we will not be expecting data to be passed to ${i} during training`), e.push(bo(t.loss[i]));
     } else if (Array.isArray(t.loss)) {
       if (t.loss.length !== this.outputs.length)
-        throw new $(`When passing an Array as loss, it should have one entry per model output. The model has ${this.outputs.length} output(s), but you passed loss=${t.loss}.`);
+        throw new I(`When passing an Array as loss, it should have one entry per model output. The model has ${this.outputs.length} output(s), but you passed loss=${t.loss}.`);
       e = t.loss.map((a) => bo(a));
     } else {
       const i = bo(t.loss);
@@ -14485,11 +14485,11 @@ class Jr extends fe {
     let o;
     if (s != null) {
       if (o = null, e != null)
-        throw new $(`If ${r} is set, batchSize must be null or undefined.Got batchSize = ${e}`);
+        throw new I(`If ${r} is set, batchSize must be null or undefined.Got batchSize = ${e}`);
     } else if (t != null)
       Array.isArray(t) ? o = t[0].shape[0] : o = t.shape[0];
     else
-      throw new $(`Either the input data should have a defined shape, or ${r} shoud be specified.`);
+      throw new I(`Either the input data should have a defined shape, or ${r} shoud be specified.`);
     return o;
   }
   /**
@@ -14501,18 +14501,18 @@ class Jr extends fe {
    */
   execute(t, e) {
     if (Array.isArray(e) && e.length === 0)
-      throw new $("`outputs` is an empty Array, which is not allowed.");
+      throw new I("`outputs` is an empty Array, which is not allowed.");
     const s = Array.isArray(e), r = s ? e : [e], o = this.retrieveSymbolicTensors(r), i = new Ue();
     if (t instanceof Et && (t = [t]), Array.isArray(t)) {
       if (t.length !== this.inputs.length)
-        throw new $(`The number of inputs provided (${t.length}) does not match the number of inputs of this model (${this.inputs.length}).`);
+        throw new I(`The number of inputs provided (${t.length}) does not match the number of inputs of this model (${this.inputs.length}).`);
       for (let l = 0; l < this.inputs.length; ++l)
         i.add(this.inputs[l], t[l]);
     } else
       for (const l of this.inputs) {
         const u = t[l.name];
         if (u == null)
-          throw new $(`No value is provided for the model's input ${l.name}`);
+          throw new I(`No value is provided for the model's input ${l.name}`);
         i.add(l, u);
       }
     const a = cs(o, i);
@@ -14538,7 +14538,7 @@ class Jr extends fe {
       const r = [];
       throw e.forEach((o, i) => {
         o == null && r.push(t[i]);
-      }), new $(`Cannot find SymbolicTensors for output name(s): ${JSON.stringify(r)}`);
+      }), new I(`Cannot find SymbolicTensors for output name(s): ${JSON.stringify(r)}`);
     }
     return e;
   }
@@ -14603,7 +14603,7 @@ class Jr extends fe {
    * @doc {heading: 'Models', subheading: 'Classes'}
    */
   predict(t, e = {}) {
-    const s = Ih(t);
+    const s = $h(t);
     il(s, this.inputNames, this.feedInputShapes, !1);
     try {
       const r = e.batchSize == null ? 32 : e.batchSize;
@@ -14641,7 +14641,7 @@ class Jr extends fe {
       this.feedLossFns[i] === Er ? o.push(a.slice(0, a.length - 1).concat([1])) : o.push(a);
     }
     if (t = ol(t, this.feedInputNames, this.feedInputShapes, !1, "input"), e = ol(e, this.feedOutputNames, o, !1, "target"), p1(t, e), m1(e, this.feedLossFns, this.feedOutputShapes), this.stateful && r != null && r > 0 && t[0].shape[0] % r !== 0)
-      throw new $(`In a stateful network, you should only pass inputs with a number of samples that is divisible by the batch size ${r}. Found: ${t[0].shape[0]} sample(s).`);
+      throw new I(`In a stateful network, you should only pass inputs with a number of samples that is divisible by the batch size ${r}. Found: ${t[0].shape[0]} sample(s).`);
     return [t, e];
   }
   async standardizeUserData(t, e, s, r, o = !0, i) {
@@ -14820,7 +14820,7 @@ class Jr extends fe {
       if (s.validationData != null && s.validationData.length > 0) {
         if (m = !0, s.validationData.length === 2)
           l = s.validationData[0], u = s.validationData[1];
-        else throw s.validationData.length === 3 ? new J("validationData including sample weights is not supported yet.") : new $(`When passing validation data, it must contain 2 (valX, valY) or 3 (valX, valY, valSampleWeight) items; ${s.validationData} is invalid.`);
+        else throw s.validationData.length === 3 ? new J("validationData including sample weights is not supported yet.") : new I(`When passing validation data, it must contain 2 (valX, valY) or 3 (valX, valY, valSampleWeight) items; ${s.validationData} is invalid.`);
         const R = await this.standardizeUserData(
           l,
           u,
@@ -14878,7 +14878,7 @@ class Jr extends fe {
     r == null && (r = 32), o == null && (o = 1), c == null && (c = !0), f == null && (f = 0);
     let g = !1;
     if (l != null && u != null && (g = !0), p != null && (g = !0, d == null))
-      throw new $("Can only use `validationSteps` when doing step-wise training, i.e., `stepsPerEpoch` must be set.");
+      throw new I("Can only use `validationSteps` when doing step-wise training, i.e., `stepsPerEpoch` must be set.");
     const m = this.checkNumSamples(e, r, d, "steps_per_epoch");
     let b;
     m != null && (b = wr(0, m)), i == null && (i = 1);
@@ -14892,7 +14892,7 @@ class Jr extends fe {
       {
         if (c === "batch")
           throw new J("batch shuffling is not implemneted yet");
-        c && If(b);
+        c && $f(b);
         const E = Dt(b), D = wo(m, r);
         for (let k = 0; k < D.length; ++k) {
           const T = {};
@@ -15199,13 +15199,13 @@ class Jr extends fe {
     if (typeof t == "string") {
       const u = nm(t);
       if (u.length === 0)
-        throw new $(`Cannot find any save handlers for URL '${t}'`);
+        throw new I(`Cannot find any save handlers for URL '${t}'`);
       if (u.length > 1)
-        throw new $(`Found more than one (${u.length}) save handlers for URL '${t}'`);
+        throw new I(`Found more than one (${u.length}) save handlers for URL '${t}'`);
       t = u[0];
     }
     if (t.save == null)
-      throw new $("LayersModel.save() cannot proceed because the IOHandler provided does not have the `save` attribute defined.");
+      throw new I("LayersModel.save() cannot proceed because the IOHandler provided does not have the `save` attribute defined.");
     const s = await Ta(this.getNamedWeights(e)), a = {
       modelTopology: this.toJSON(null, !1),
       format: b1,
@@ -15274,8 +15274,8 @@ const {
   ownKeys: _h,
   set: hl,
   setPrototypeOf: Ch
-} = Reflect, $1 = Proxy, {
-  EPSILON: I1,
+} = Reflect, I1 = Proxy, {
+  EPSILON: $1,
   MAX_SAFE_INTEGER: fl,
   isFinite: kh,
   isNaN: Un
@@ -15314,27 +15314,27 @@ const {
 ), Xi = Qr[ke], D1 = ct(Xi), {
   abs: P1,
   trunc: Dh
-} = Math, to = ArrayBuffer, R1 = to.isView, Ph = to.prototype, L1 = ct(Ph.slice), O1 = Qn(Ph, "byteLength"), ei = typeof SharedArrayBuffer < "u" ? SharedArrayBuffer : null, M1 = ei && Qn(ei.prototype, "byteLength"), Ji = Ms(Uint8Array), B1 = Ji.from, $t = Ji.prototype, F1 = $t[ke], z1 = ct($t.keys), U1 = ct(
-  $t.values
+} = Math, to = ArrayBuffer, R1 = to.isView, Ph = to.prototype, L1 = ct(Ph.slice), O1 = Qn(Ph, "byteLength"), ei = typeof SharedArrayBuffer < "u" ? SharedArrayBuffer : null, M1 = ei && Qn(ei.prototype, "byteLength"), Ji = Ms(Uint8Array), B1 = Ji.from, It = Ji.prototype, F1 = It[ke], z1 = ct(It.keys), U1 = ct(
+  It.values
 ), W1 = ct(
-  $t.entries
-), G1 = ct($t.set), pl = ct(
-  $t.reverse
-), V1 = ct($t.fill), q1 = ct(
-  $t.copyWithin
-), ml = ct($t.sort), as = ct($t.slice), j1 = ct(
-  $t.subarray
+  It.entries
+), G1 = ct(It.set), pl = ct(
+  It.reverse
+), V1 = ct(It.fill), q1 = ct(
+  It.copyWithin
+), ml = ct(It.sort), as = ct(It.slice), j1 = ct(
+  It.subarray
 ), xt = Qn(
-  $t,
+  It,
   "buffer"
 ), Xe = Qn(
-  $t,
+  It,
   "byteOffset"
 ), tt = Qn(
-  $t,
+  It,
   "length"
 ), Rh = Qn(
-  $t,
+  It,
   Yi
 ), H1 = Uint8Array, Ht = Uint16Array, gl = (...n) => Ft(B1, Ht, n), Zi = Uint32Array, K1 = Float32Array, yn = Ms([][ke]()), eo = ct(yn.next), Y1 = ct(function* () {
 }().next), X1 = Ms(yn), ft = TypeError, vo = RangeError, Lh = WeakSet, Oh = Lh.prototype, J1 = ct(Oh.add), Z1 = ct(Oh.has), no = WeakMap, Qi = no.prototype, Tr = ct(Qi.get), Q1 = ct(Qi.has), ta = ct(Qi.set), Mh = new no(), tx = Zr(null, {
@@ -15436,7 +15436,7 @@ function rx(n) {
     throw ft(Eh);
   return Qo(e, Pr);
 }
-const si = 1 / I1;
+const si = 1 / $1;
 function ox(n) {
   return n + si - si;
 }
@@ -15489,7 +15489,7 @@ function De(n) {
   const t = +n;
   return Un(t) || t === 0 ? 0 : Dh(t);
 }
-function $o(n) {
+function Io(n) {
   const t = De(n);
   return t < 0 ? 0 : t < fl ? t : fl;
 }
@@ -15589,10 +15589,10 @@ function vl(n) {
   return e;
 }
 const Hh = new Lh();
-for (const n of _h($t)) {
+for (const n of _h(It)) {
   if (n === Yi)
     continue;
-  const t = zn($t, n);
+  const t = zn(It, n);
   Le(t, "get") && typeof t.get == "function" && J1(Hh, t.get);
 }
 const ux = _1(
@@ -15641,7 +15641,7 @@ class ht {
           throw ft(ll);
         l != null ? wl(t) ? (i = t, a = t.length) : (i = [.../** @type {Iterable<unknown>} */
         t], a = i.length) : (i = /** @type {ArrayLike<unknown>} */
-        t, a = $o(i.length)), r = hs(Ht, [a], new.target);
+        t, a = Io(i.length)), r = hs(Ht, [a], new.target);
       }
       for (let l = 0; l < a; ++l)
         r[l] = xe(i[l]);
@@ -15649,7 +15649,7 @@ class ht {
       r = hs(Ht, arguments, new.target);
     const o = (
       /** @type {any} */
-      new $1(r, ux)
+      new I1(r, ux)
     );
     return ta(Rr, o, r), o;
   }
@@ -15702,7 +15702,7 @@ class ht {
         throw ft(
           Jo
         );
-      r = Wn(t), o = $o(r.length);
+      r = Wn(t), o = Io(r.length);
     }
     const a = new s(o);
     if (e.length === 0)
@@ -15970,7 +15970,7 @@ class ht {
       if (bs(l))
         throw ft(gs);
     }
-    const o = tt(s), i = Wn(t), a = $o(i.length);
+    const o = tt(s), i = Wn(t), a = Io(i.length);
     if (r === 1 / 0 || a + r > o)
       throw vo(xo);
     for (let l = 0; l < a; ++l)
@@ -16162,7 +16162,7 @@ Bs(Lr, ke, {
   writable: !0,
   configurable: !0
 });
-Ch(Lr, $t);
+Ch(Lr, It);
 function cx(n, t) {
   return n.channels === t.channels;
 }
@@ -16378,7 +16378,7 @@ function hx(n) {
   return n <= Xh ? n = n / sa : n <= Jh ? n = Math.pow((n - ia) / ra, 1 / oa) : n = Math.exp((n - ua) / aa) - la, n;
 }
 const fx = 65504, Qh = Zh(fx), tf = 1 / Qh, ef = Qh;
-class Io {
+class $o {
   constructor(t, e, s, r) {
     this.x = t, this.y = e, this.width = s, this.height = r;
   }
@@ -16424,7 +16424,7 @@ function mx({
     }
   return s;
 }
-const $l = `
+const Il = `
 const a = ${sa};
 const b = ${ra};
 const c = ${oa};
@@ -16456,18 +16456,18 @@ class gx {
       },
       {
         label: "inputSize",
-        type: "vec2<f32>",
-        data: new Float32Array(2)
+        type: "vec2i",
+        data: new Int32Array(2)
       },
       {
         label: "outputSize",
-        type: "vec2<f32>",
-        data: new Float32Array(2)
+        type: "vec2i",
+        data: new Int32Array(2)
       },
       {
         label: "inputOffset",
-        type: "vec2<f32>",
-        data: new Float32Array(2)
+        type: "vec2i",
+        data: new Int32Array(2)
       }
     ];
     this._inputPassAux = new Js("inputPassAux", this._device, {
@@ -16493,28 +16493,28 @@ class gx {
         },
         {
           label: "inputSize",
-          type: "vec2<f32>",
-          data: new Float32Array(2)
+          type: "vec2i",
+          data: new Int32Array(2)
         },
         {
           label: "outputSize",
-          type: "vec2<f32>",
-          data: new Float32Array(2)
+          type: "vec2i",
+          data: new Int32Array(2)
         },
         {
           label: "imageSize",
-          type: "vec2<f32>",
-          data: new Float32Array(2)
+          type: "vec2i",
+          data: new Int32Array(2)
         },
         {
           label: "inputOffset",
-          type: "vec2<f32>",
-          data: new Float32Array(2)
+          type: "vec2i",
+          data: new Int32Array(2)
         },
         {
           label: "outputOffset",
-          type: "vec2<f32>",
-          data: new Float32Array(2)
+          type: "vec2i",
+          data: new Int32Array(2)
         }
       ],
       csDefine: "",
@@ -16526,8 +16526,8 @@ class gx {
       uniforms: [
         {
           label: "size",
-          type: "vec2<f32>",
-          data: new Float32Array(2)
+          type: "vec2i",
+          data: new Int32Array(2)
         }
       ],
       csMain: (
@@ -16554,7 +16554,7 @@ out_color[outIdx] = textureLoad(in_color, globalId.xy, 0);
     const s = this._isHDR, r = (
       /* wgsl */
       `
-${$l}
+${Il}
 fn PUForward(y: f32) -> f32 {
   if (y <= y0) {
     return a * y;
@@ -16571,12 +16571,12 @@ fn PUForward(y: f32) -> f32 {
     const i = (
       /* wgsl */
       `
-let x = f32(globalId.x);
-let y = f32(globalId.y);
-let inIdx = i32((y + inputOffset.y) * inputSize.x + (x + inputOffset.x));
+let x = i32(globalId.x);
+let y = i32(globalId.y);
+let inIdx = (y + inputOffset.y) * inputSize.x + (x + inputOffset.x);
 let col = ${o("color")};
 
-let outIdx = i32(y * outputSize.x + x);
+let outIdx = y * outputSize.x + x;
 
 if (${e}) {
   // Denoise the inversed alpha. Or the anti aliased edge will be too dark after denoised
@@ -16614,7 +16614,7 @@ ${i}
       csDefine: (
         /* wgsl */
         `
-${$l}
+${Il}
 fn PUInverse(y: f32) -> f32 {
   if (y <= x0) {
     return y / a;
@@ -16629,13 +16629,13 @@ fn PUInverse(y: f32) -> f32 {
       csMain: (
         /* wgsl */
         `
-let x = f32(globalId.x);
-let y = f32(globalId.y);
+let x = i32(globalId.x);
+let y = i32(globalId.y);
 if (x >= outputSize.x || y >= outputSize.y) {
   return;
 }
-let inIdx = i32((y + inputOffset.y) * inputSize.x + x + inputOffset.x);
-let outIdx = i32((y + outputOffset.y) * imageSize.x + x + outputOffset.x);
+let inIdx = (y + inputOffset.y) * inputSize.x + x + inputOffset.x;
+let outIdx = (y + outputOffset.y) * imageSize.x + x + outputOffset.x;
 let col = in_color[inIdx];
 let raw = ${t ? "textureLoad(in_raw, globalId.xy + vec2u(outputOffset), 0)" : "in_raw[outIdx]"};
 
@@ -16657,19 +16657,19 @@ else {
     });
   }
   setImageSize(t, e) {
-    this._inputPassAux.setUniform("inputSize", new Float32Array([t, e])), this._inputPassColor.setUniform("inputSize", new Float32Array([t, e])), this._outputPass.setUniform("imageSize", new Float32Array([t, e])), this._outputPass.setSize(t, e), this._copyPass.setSize(t, e), this._copyPass.setUniform("size", new Float32Array([t, e]));
+    this._inputPassAux.setUniform("inputSize", new Int32Array([t, e])), this._inputPassColor.setUniform("inputSize", new Int32Array([t, e])), this._outputPass.setUniform("imageSize", new Int32Array([t, e])), this._outputPass.setSize(t, e), this._copyPass.setSize(t, e), this._copyPass.setUniform("size", new Int32Array([t, e]));
   }
   setInputTile(t) {
-    const e = new Float32Array([t.width, t.height]);
+    const e = new Int32Array([t.width, t.height]);
     [this._inputPassAux, this._inputPassColor].forEach((s) => {
-      s.setUniform("inputOffset", new Float32Array([t.x, t.y])), s.setUniform("outputSize", e), s.setSize(e[0], e[1]);
+      s.setUniform("inputOffset", new Int32Array([t.x, t.y])), s.setUniform("outputSize", e), s.setSize(e[0], e[1]);
     }), this._outputPass.setUniform("inputSize", e);
   }
   setOutputTile(t, e) {
-    const s = this._outputPass, r = new Float32Array([t.width, t.height]), o = t.x - e.x, i = t.y - e.y;
-    s.setUniform("outputSize", r), s.setUniform("inputOffset", new Float32Array([o, i])), s.setUniform(
+    const s = this._outputPass, r = new Int32Array([t.width, t.height]), o = t.x - e.x, i = t.y - e.y;
+    s.setUniform("outputSize", r), s.setUniform("inputOffset", new Int32Array([o, i])), s.setUniform(
       "outputOffset",
-      new Float32Array([t.x, t.y])
+      new Int32Array([t.x, t.y])
     ), s.setExecuteSize(r[0], r[1]);
   }
   forward(t, e, s, r) {
@@ -16724,7 +16724,7 @@ else {
     this._outputPass.dispose(), this._inputPassAux.dispose();
   }
 }
-function Il(n, t) {
+function $l(n, t) {
   const e = n.buffer;
   if (t === "Float32")
     return new Float32Array(n.buffer);
@@ -16796,7 +16796,7 @@ class xx {
       const h = u.desc.dims;
       a = nr(
         bx(
-          Il(u.data, u.desc.dataType),
+          $l(u.data, u.desc.dataType),
           h
         ),
         [h[2], h[3], h[1], h[0]],
@@ -16806,7 +16806,7 @@ class xx {
     if (!l) {
       const h = this._hostTensors.get(t + ".bias");
       l = Dt(
-        Il(h.data, h.desc.dataType),
+        $l(h.data, h.desc.dataType),
         "float32"
       ), i.set(o, l);
     }
@@ -16940,7 +16940,7 @@ class xx {
     g = Math.max(m - d.width, 0);
     let b = o > 0 ? o * p.height - f : 0, y = Math.min(b + d.height, a);
     b = Math.max(y - d.height, 0);
-    const S = d.width, x = d.height, v = new Io(g, b, S, x);
+    const S = d.width, x = d.height, v = new $o(g, b, S, x);
     let E, D = 1;
     const k = this._device;
     let T = this._dataProcessGPU;
@@ -16990,7 +16990,7 @@ class xx {
         E = Ot(U);
     }
     let R;
-    const B = this._tfModel.predict(E), H = Math.min(p.width, i), X = Math.min(p.height, a), W = new Io(r * H, o * X, H, X);
+    const B = this._tfModel.predict(E), H = Math.min(p.width, i), X = Math.min(p.height, a), W = new $o(r * H, o * X, H, X);
     if (W.width = Math.min(W.width, i - W.x), W.height = Math.min(W.height, a - W.y), t instanceof Float32Array) {
       let U = B.dataSync();
       l && (U = mx({
@@ -17086,7 +17086,7 @@ class xx {
         D,
         // Is undefined if using webgpu buffer
         b,
-        new Io(x * h, v * f, h, f),
+        new $o(x * h, v * f, h, f),
         x + v * p,
         p * d
       ), x + 1 < p || v + 1 < d ? requestAnimationFrame(() => {
@@ -17235,7 +17235,7 @@ function El(n, t) {
  * limitations under the License.
  * =============================================================================
  */
-class $x {
+class Ix {
   constructor(t) {
     this.device = t, this.numUsedTextures = 0, this.numFreeTextures = 0, this.freeTextures = /* @__PURE__ */ new Map(), this.usedTextures = /* @__PURE__ */ new Map(), this.numBytesUsed = 0, this.numBytesAllocated = 0;
   }
@@ -17308,7 +17308,7 @@ function Cl(n) {
  * limitations under the License.
  * =============================================================================
  */
-function Ix(n, t) {
+function $x(n, t) {
   if (Math.max(...n) > 5)
     throw new Error("Cannot symbolically compute strides for rank > 6 tensor.");
   const e = n.length, s = "xyzwuv", r = n.map((i) => `${t}.${s[i]}`), o = new Array(e - 1);
@@ -17706,7 +17706,7 @@ function Rx(n, t) {
       if (d.length === 1)
         a += `let d${d[0]} = i32(globalId[${f}]);`;
       else {
-        const p = Ix(d, "uniforms.outShape");
+        const p = $x(d, "uniforms.outShape");
         a += `var index${f} = i32(globalId[${f}]);`;
         for (let g = 0; g < p.length; g++)
           a += `let d${d[g]} = index${f} / ${p[g]};`, g === p.length - 1 ? a += `let d${d[g + 1]} = index${f} - d${d[g]} * ${p[g]};` : a += `index${f} = index${f} - d${d[g]} * ${p[g]};`;
@@ -17849,7 +17849,7 @@ const hn = (n) => {
     t *= n[e];
   return t;
 };
-function It(n, t, e = [1, 1, 1], s = [1, 1, 1]) {
+function $t(n, t, e = [1, 1, 1], s = [1, 1, 1]) {
   const [r, o, i] = [
     Math.ceil(hn(n.x.map((a) => t[a])) / (e[0] * s[0])),
     n.y ? Math.ceil(hn(n.y.map((a) => t[a])) / (e[1] * s[1])) : 1,
@@ -17921,7 +17921,7 @@ class Fs extends Bl {
   constructor(t, e) {
     if (super(), this.commandQueueOwnedIds = /* @__PURE__ */ new WeakSet(), this.dispatchCountInPass = 0, this.disposed = !1, this.downloadWaitMs = 0, this.tensorDataPendingDisposal = [], this.queryResolveBuffer = null, this.querySet = null, this.querySetCount = 2, this.stagingPendingDisposal = [], this.uniformPendingDisposal = [], this.uploadWaitMs = 0, this.hasReadSyncWarned = !1, this.hasTimestampQueryWarned = !1, !rf())
       throw new Error("WebGPU is not supported on this device");
-    this.pipelineCache = {}, this.device = t, this.queue = t.queue, this.commandEncoder = null, this.computePassEncoder = null, this.adapterInfo = new Sx(e), this.supportTimestampQuery = this.device.features.has("timestamp-query"), this.thresholdToIncreaseWorkgroups = this.adapterInfo.intelGPUGeneration >= 12 ? 16 : 8, this.bufferManager = new vx(this.device), this.textureManager = new $x(this.device), this.tensorMap = new $f(this, uo()), V().getBool("WEBGPU_USE_PROFILE_TOOL") && (this.dummyCanvas = document.createElement("canvas"), this.dummyCanvas.width = 1, this.dummyCanvas.height = 1, this.dummyContext = this.dummyCanvas.getContext("webgpu"), this.dummyContext.configure({
+    this.pipelineCache = {}, this.device = t, this.queue = t.queue, this.commandEncoder = null, this.computePassEncoder = null, this.adapterInfo = new Sx(e), this.supportTimestampQuery = this.device.features.has("timestamp-query"), this.thresholdToIncreaseWorkgroups = this.adapterInfo.intelGPUGeneration >= 12 ? 16 : 8, this.bufferManager = new vx(this.device), this.textureManager = new Ix(this.device), this.tensorMap = new If(this, uo()), V().getBool("WEBGPU_USE_PROFILE_TOOL") && (this.dummyCanvas = document.createElement("canvas"), this.dummyCanvas.width = 1, this.dummyCanvas.height = 1, this.dummyContext = this.dummyCanvas.getContext("webgpu"), this.dummyContext.configure({
       device: t,
       format: "bgra8unorm"
     }), document.body.appendChild(this.dummyCanvas));
@@ -18350,7 +18350,7 @@ rf() && Xp(
       maxComputeWorkgroupSizeX: r.maxComputeWorkgroupSizeX,
       maxComputeInvocationsPerWorkgroup: r.maxComputeInvocationsPerWorkgroup
     };
-    const o = await t.requestDevice(e), i = "info" in t ? t.info : "requestAdapterInfo" in t ? await t.requestAdapterInfo() : void 0;
+    const o = await t.requestDevice(e), i = await t.requestAdapterInfo();
     return new Fs(o, i);
   },
   3
@@ -18377,7 +18377,7 @@ class Gx {
     this.uniforms = "", this.variableNames = ["x"], this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = e.map(
       (r, o) => r[0] + t[o] + r[1]
       /* afterPad */
-    ), this.dispatchLayout = ae(this.outputShape), this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize), this.xShape = t, e.map((r, o) => {
+    ), this.dispatchLayout = ae(this.outputShape), this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize), this.xShape = t, e.map((r, o) => {
       this.uniforms += ` pad${o} : vec2<i32>,`;
     }), this.offset = s === "reflect" ? 0 : 1, this.shaderKey = `mirrorPad_${s}`;
   }
@@ -18486,7 +18486,7 @@ class Hx {
     this.variableNames = ["x"], this.uniforms = "constantValue : f32,", this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = e.map(
       (s, r) => s[0] + t[r] + s[1]
       /* afterPad */
-    ), this.dispatchLayout = ae(this.outputShape), this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize), e.map((s, r) => {
+    ), this.dispatchLayout = ae(this.outputShape), this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize), e.map((s, r) => {
       this.uniforms += ` pad${r} : vec2<i32>,`;
     }), this.xShape = t, this.shaderKey = "pad";
   }
@@ -18519,7 +18519,7 @@ class Hx {
  */
 class Kx {
   constructor(t) {
-    this.variableNames = [], this.outputShape = [], this.uniforms = "value : f32,", this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = t, this.dispatchLayout = ae(this.outputShape), this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize), this.shaderKey = "fill";
+    this.variableNames = [], this.outputShape = [], this.uniforms = "value : f32,", this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = t, this.dispatchLayout = ae(this.outputShape), this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize), this.shaderKey = "fill";
   }
   getUserCode() {
     return `
@@ -19215,7 +19215,7 @@ const vS = Lt((n, t) => n !== t ? 1 : 0);
  * limitations under the License.
  * =============================================================================
  */
-function $S(n, t, e, s, r) {
+function IS(n, t, e, s, r) {
   const o = t.length, i = z(t), a = Kt(t), l = Kt(r), u = Rn(e, z(r));
   for (let c = 0; c < i; ++c) {
     const h = oi(c, o, a), f = new Array(h.length);
@@ -19242,7 +19242,7 @@ function $S(n, t, e, s, r) {
  * limitations under the License.
  * =============================================================================
  */
-function IS(n, t, e, s) {
+function $S(n, t, e, s) {
   const [r, o] = bi(n, s), i = ci(t, "int32"), a = je(z(r), i), l = z(o);
   for (let u = 0; u < a.length; ++u) {
     const c = u * l;
@@ -19430,7 +19430,7 @@ function DS(n, t, e, s, r, o, i) {
  * limitations under the License.
  * =============================================================================
  */
-var Zt = Ie;
+var Zt = $e;
 class Mr {
   constructor(t, e, s, r, o, i, a, l, u, c) {
     this.shape = t, this.shapeShape = e, this.values = s, this.valuesShape = r, this.valuesDType = o, this.defaultValue = i, this.defaultValueShape = a, this.rowPartitionValues = l, this.rowPartitionValuesShapes = u, this.rowPartitionTypes = dy(c), this.raggedRank = py(this.rowPartitionTypes);
@@ -19824,7 +19824,7 @@ function FS(n, t, e, s, r, o, i) {
   const a = t[0], l = o[0], u = new Array(l), c = new Array(a), h = t[1];
   if (l === 0) {
     if (a !== 0)
-      throw new Error(Iy(a));
+      throw new Error($y(a));
     const m = yt(e, 0), b = yt(r, 0);
     return [
       m,
@@ -20479,7 +20479,7 @@ const e2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   multiplyImpl: af,
   negImpl: SS,
   notEqualImpl: vS,
-  prodImpl: IS,
+  prodImpl: $S,
   raggedGatherImpl: NS,
   raggedRangeImpl: DS,
   raggedTensorToTensorImpl: PS,
@@ -20502,7 +20502,7 @@ const e2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   subImpl: JS,
   tileImpl: ZS,
   topKImpl: QS,
-  transposeImpl: $S,
+  transposeImpl: IS,
   uniqueImpl: t2
 }, Symbol.toStringTag, { value: "Module" }));
 /**
@@ -20521,7 +20521,7 @@ const e2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
  * limitations under the License.
  * =============================================================================
  */
-const { addImpl: E$, castImpl: _$, ceilImpl: C$, concatImpl: n2, equalImpl: k$, expImpl: T$, expm1Impl: N$, floorImpl: D$, floorDivImpl: P$, gatherNdImpl: R$, gatherV2Impl: L$, greaterEqualImpl: O$, greaterImpl: M$, lessEqualImpl: B$, lessImpl: F$, logImpl: z$, maxImpl: s2, maximumImpl: U$, minimumImpl: W$, multiplyImpl: G$, negImpl: V$, notEqualImpl: q$, prodImpl: r2, rangeImpl: j$, rsqrtImpl: H$, scatterImpl: K$, simpleAbsImpl: Y$, sliceImpl: o2, stridedSliceImpl: X$, stringNGramsImpl: J$, subImpl: Z$, tileImpl: Q$, topKImpl: tI, transposeImpl: i2, uniqueImpl: eI } = e2;
+const { addImpl: EI, castImpl: _I, ceilImpl: CI, concatImpl: n2, equalImpl: kI, expImpl: TI, expm1Impl: NI, floorImpl: DI, floorDivImpl: PI, gatherNdImpl: RI, gatherV2Impl: LI, greaterEqualImpl: OI, greaterImpl: MI, lessEqualImpl: BI, lessImpl: FI, logImpl: zI, maxImpl: s2, maximumImpl: UI, minimumImpl: WI, multiplyImpl: GI, negImpl: VI, notEqualImpl: qI, prodImpl: r2, rangeImpl: jI, rsqrtImpl: HI, scatterImpl: KI, simpleAbsImpl: YI, sliceImpl: o2, stridedSliceImpl: XI, stringNGramsImpl: JI, subImpl: ZI, tileImpl: QI, topKImpl: t$, transposeImpl: i2, uniqueImpl: e$ } = e2;
 /**
  * @license
  * Copyright 2019 Google LLC. All Rights Reserved.
@@ -20540,7 +20540,7 @@ const { addImpl: E$, castImpl: _$, ceilImpl: C$, concatImpl: n2, equalImpl: k$,
  */
 class a2 {
   constructor(t, e) {
-    this.variableNames = ["source"], this.workPerThread = 1, this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = e, this.rank = e.length, this.dispatchLayout = ae(this.outputShape), this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize, [this.workPerThread, 1, 1]), this.start = t, this.uniforms = `start : ${Tt(t.length)}, `, this.shaderKey = "slice";
+    this.variableNames = ["source"], this.workPerThread = 1, this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = e, this.rank = e.length, this.dispatchLayout = ae(this.outputShape), this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize, [this.workPerThread, 1, 1]), this.start = t, this.uniforms = `start : ${Tt(t.length)}, `, this.shaderKey = "slice";
   }
   getUserCode() {
     const t = Tt(this.rank), e = l2(this.rank);
@@ -20644,7 +20644,7 @@ const h2 = "let resultTemp = a + b;", f2 = "let resultTemp = atan2(a, b);", d2 =
   let zero = sign(a) * 0 + 0;
   let one = sign(b) * 0 + 1;
   let resultTemp = select(zero, one, a <= b);
-`, $2 = "return f32(a >= 1.0 && b >= 1.0);", I2 = `return (vec4<f32>(a >= vec4<f32>(1.0)) *
+`, I2 = "return f32(a >= 1.0 && b >= 1.0);", $2 = `return (vec4<f32>(a >= vec4<f32>(1.0)) *
   vec4<f32>(b >= vec4<f32>(1.0)));`, A2 = "return f32(a >= 1.0 || b >= 1.0);", E2 = `return min(vec4<f32>(a >= vec4<f32>(1.0)) +
   vec4<f32>(b >= vec4<f32>(1.0)), vec4<f32>(1.0));`, _2 = "let resultTemp = max(a, b);", C2 = "let resultTemp = min(a, b);", k2 = `
   let isNaN = b == 0.;
@@ -20782,7 +20782,7 @@ function z2(n, t) {
       e = v2;
       break;
     case it.LOGICAL_AND:
-      return t ? I2 : $2;
+      return t ? $2 : I2;
     case it.LOGICAL_OR:
       return t ? E2 : A2;
     case it.MUL:
@@ -20880,7 +20880,7 @@ const U2 = "return abs(a);", W2 = `
   let a2 = ${xy};
   let a3 = ${Sy};
   let a4 = ${vy};
-  let a5 = ${$y};
+  let a5 = ${Iy};
 
   let sign = sign(a);
   let absA = abs(a);
@@ -20901,7 +20901,7 @@ const U2 = "return abs(a);", W2 = `
   } else {
     return ${gy} * (exp(a) - 1.0);
   }
-`, Sv = "return 1.0 / (1.0 + exp(-1.0 * a));", vv = "return sign(a);", $v = "return sin(a);", Iv = `
+`, Sv = "return 1.0 / (1.0 + exp(-1.0 * a));", vv = "return sign(a);", Iv = "return sin(a);", $v = `
   let e2x = exp(a);
   return (e2x - 1.0 / e2x) / 2.0;
 `, Av = `
@@ -20996,9 +20996,9 @@ function An(n, t) {
     case F.SIGN:
       return vv;
     case F.SIN:
-      return $v;
-    case F.SINH:
       return Iv;
+    case F.SINH:
+      return $v;
     case F.SOFTPLUS:
       return Av;
     case F.SQRT:
@@ -21420,7 +21420,7 @@ class Mv {
       const f = Bx(e[1], u, e[2], s);
       this.workgroupSize = f.workgroupSize, this.elementsPerThread = f.elementsPerThread;
     }
-    this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize, this.elementsPerThread);
+    this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize, this.elementsPerThread);
     const c = o != null, h = a != null;
     c && this.variableNames.push("bias"), h && this.variableNames.push("preluActivationWeights"), this.sequentialAccessByThreads = l, this.transposeA = s, this.transposeB = r, this.addBias = c, this.activation = i, this.hasPreluActivationWeights = h, [this.fitAOuter, this.fitBOuter, this.fitInner] = this.getShapeFit(e[1], e[2], u), this.shaderKey = `matMulPacked_${this.elementsPerThread}_${s}_${r}_${this.activation}_${this.fitAOuter}_${this.fitBOuter}_${this.fitInner}_${this.isVec4}_${this.isVectorA}_${this.sequentialAccessByThreads}`;
   }
@@ -21544,7 +21544,7 @@ function Bv(n, t, e, s, r = !1, o = null, i = !1, a = 4, l = 4, u = 4) {
 }
 class Fv {
   constructor(t, e, s, r, o = !1, i = null, a = !1, l = !1) {
-    this.variableNames = ["x", "W"], this.uniforms = "filterDims : vec2<i32>, pads : vec2<i32>, strides : vec2<i32>, dilations : vec2<i32>, dimAOuter : i32, dimBOuter : i32, dimInner : i32,", this.outputShape = t.outShape, this.isChannelsLast = t.dataFormat === "channelsLast", this.isVec4 = ((t.inChannels % 4 === 0 || t.inChannels % 3 === 0) && this.isChannelsLast || t.outWidth % 4 === 0 && !this.isChannelsLast) && t.outChannels % 4 === 0, this.dispatchLayout = this.isChannelsLast ? { x: [3], y: [1, 2], z: [0] } : { x: [2, 3], y: [1], z: [0] }, this.workgroupSize = Fx(this.dispatchLayout, this.outputShape, this.isVec4), this.elementsPerThread = zx(this.dispatchLayout, this.outputShape, this.isVec4), this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize, this.elementsPerThread), this.isVec4 ? (this.outputComponent = 4, this.isChannelsLast && t.inChannels % 4 !== 0 ? (this.innerElementSize = 3, this.variableComponents = [1, 4]) : (this.innerElementSize = 4, this.variableComponents = [4, 4]), o && (this.variableNames.push("bias"), this.variableComponents.push(4)), a && (this.variableNames.push("preluActivationWeights"), this.variableComponents.push(4))) : (this.innerElementSize = this.elementsPerThread[0], o && this.variableNames.push("bias"), a && this.variableNames.push("preluActivationWeights")), this.sequentialAccessByThreads = l, this.addBias = o, this.activation = i, this.hasPreluActivationWeights = a, this.tileAOuter = this.workgroupSize[1] * this.elementsPerThread[1], this.tileBOuter = this.workgroupSize[0] * this.elementsPerThread[0], this.tileInner = Math.max(this.workgroupSize[0] * this.innerElementSize, this.workgroupSize[1]), this.fitAOuter = e % this.tileAOuter === 0, this.fitBOuter = s % this.tileBOuter === 0, this.fitInner = r % this.tileInner === 0, this.shaderKey = `conv2DMM_${this.elementsPerThread}_${this.activation}}_${this.fitAOuter}_${this.fitBOuter}_${this.fitInner}_${this.isVec4}_${this.innerElementSize}_${this.isChannelsLast}_${this.sequentialAccessByThreads}`;
+    this.variableNames = ["x", "W"], this.uniforms = "filterDims : vec2<i32>, pads : vec2<i32>, strides : vec2<i32>, dilations : vec2<i32>, dimAOuter : i32, dimBOuter : i32, dimInner : i32,", this.outputShape = t.outShape, this.isChannelsLast = t.dataFormat === "channelsLast", this.isVec4 = ((t.inChannels % 4 === 0 || t.inChannels % 3 === 0) && this.isChannelsLast || t.outWidth % 4 === 0 && !this.isChannelsLast) && t.outChannels % 4 === 0, this.dispatchLayout = this.isChannelsLast ? { x: [3], y: [1, 2], z: [0] } : { x: [2, 3], y: [1], z: [0] }, this.workgroupSize = Fx(this.dispatchLayout, this.outputShape, this.isVec4), this.elementsPerThread = zx(this.dispatchLayout, this.outputShape, this.isVec4), this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize, this.elementsPerThread), this.isVec4 ? (this.outputComponent = 4, this.isChannelsLast && t.inChannels % 4 !== 0 ? (this.innerElementSize = 3, this.variableComponents = [1, 4]) : (this.innerElementSize = 4, this.variableComponents = [4, 4]), o && (this.variableNames.push("bias"), this.variableComponents.push(4)), a && (this.variableNames.push("preluActivationWeights"), this.variableComponents.push(4))) : (this.innerElementSize = this.elementsPerThread[0], o && this.variableNames.push("bias"), a && this.variableNames.push("preluActivationWeights")), this.sequentialAccessByThreads = l, this.addBias = o, this.activation = i, this.hasPreluActivationWeights = a, this.tileAOuter = this.workgroupSize[1] * this.elementsPerThread[1], this.tileBOuter = this.workgroupSize[0] * this.elementsPerThread[0], this.tileInner = Math.max(this.workgroupSize[0] * this.innerElementSize, this.workgroupSize[1]), this.fitAOuter = e % this.tileAOuter === 0, this.fitBOuter = s % this.tileBOuter === 0, this.fitInner = r % this.tileInner === 0, this.shaderKey = `conv2DMM_${this.elementsPerThread}_${this.activation}}_${this.fitAOuter}_${this.fitBOuter}_${this.fitInner}_${this.isVec4}_${this.innerElementSize}_${this.isChannelsLast}_${this.sequentialAccessByThreads}`;
   }
   getUserCode() {
     const t = this.isVec4 ? ha(this.elementsPerThread, this.workgroupSize, !this.isChannelsLast, this.tileInner) : fa(this.elementsPerThread, this.workgroupSize, !this.isChannelsLast, this.tileInner, !1, null, this.sequentialAccessByThreads), e = this.isVec4 ? [this.innerElementSize, 4, 4] : [1, 1, 1];
@@ -21572,7 +21572,7 @@ class Fv {
  */
 class zv {
   constructor(t, e = !1, s = null, r = !1) {
-    this.variableNames = ["x", "W"], this.uniforms = "filterDims: vec2<i32>, pads: vec2<i32>, strides: vec2<i32>, dilations: vec2<i32>,", this.workgroupSize = [4, 4, 8], this.outputShape = t.outShape, this.isChannelsLast = t.dataFormat === "channelsLast", this.dispatchLayout = this.isChannelsLast ? { x: [2], y: [1], z: [0, 3] } : { x: [3], y: [2], z: [0, 1] }, this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize), this.addBias = e, this.activation = s, this.hasPreluActivationWeights = r, e && this.variableNames.push("bias"), r && this.variableNames.push("preluActivationWeights"), this.shaderKey = `conv2dnaive_${this.activation}_${this.isChannelsLast}`;
+    this.variableNames = ["x", "W"], this.uniforms = "filterDims: vec2<i32>, pads: vec2<i32>, strides: vec2<i32>, dilations: vec2<i32>,", this.workgroupSize = [4, 4, 8], this.outputShape = t.outShape, this.isChannelsLast = t.dataFormat === "channelsLast", this.dispatchLayout = this.isChannelsLast ? { x: [2], y: [1], z: [0, 3] } : { x: [3], y: [2], z: [0, 1] }, this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize), this.addBias = e, this.activation = s, this.hasPreluActivationWeights = r, e && this.variableNames.push("bias"), r && this.variableNames.push("preluActivationWeights"), this.shaderKey = `conv2dnaive_${this.activation}_${this.isChannelsLast}`;
   }
   getUserCode() {
     return `
@@ -21643,7 +21643,7 @@ class zv {
 class Uv {
   constructor(t, e) {
     this.variableNames = ["x"], this.uniforms = `pads : vec2<i32>, strides : vec2<i32>, dilations : vec2<i32>, outWidth : i32, itemsPerBlockRow : i32,
-       inChannels : i32,`, this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = t, this.dispatchLayout = ae(this.outputShape), this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize), this.isChannelsLast = e, this.shaderKey = `im2col_${this.isChannelsLast}`;
+       inChannels : i32,`, this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = t, this.dispatchLayout = ae(this.outputShape), this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize), this.isChannelsLast = e, this.shaderKey = `im2col_${this.isChannelsLast}`;
   }
   getUserCode() {
     const t = this.isChannelsLast ? 1 : 2, e = this.isChannelsLast ? 2 : 3, s = this.isChannelsLast ? "coords[1]" : "coords[2]", r = this.isChannelsLast ? "coords[2]" : "coords[1]", o = this.isChannelsLast ? "getX(batch, xRow, xCol, ch)" : "getX(batch, ch, xRow, xCol)";
@@ -21727,7 +21727,7 @@ function Wv(n) {
 }
 class Gv {
   constructor(t, e = !1, s = !1, r = null, o = null, i = null) {
-    this.variableNames = ["A", "B"], this.uniforms = "dimAOuter : i32, dimBOuter : i32, dimInner : i32,", this.workgroupSize = [256, 1, 1], this.outputShape = t, this.dispatchLayout = { x: [], y: [1, 2], z: [0] }, this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize);
+    this.variableNames = ["A", "B"], this.uniforms = "dimAOuter : i32, dimBOuter : i32, dimInner : i32,", this.workgroupSize = [256, 1, 1], this.outputShape = t, this.dispatchLayout = { x: [], y: [1, 2], z: [0] }, this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize);
     const a = r != null, l = i != null;
     a && this.variableNames.push("bias"), l && this.variableNames.push("preluActivationWeights"), this.transposeA = e, this.transposeB = s, this.addBias = a, this.activation = o, this.hasPreluActivationWeights = l, this.shaderKey = `matMulReduce_${this.activation}_${e}_${s}`;
   }
@@ -21851,7 +21851,7 @@ class jv {
   constructor(t, e, s = !1, r = !1) {
     this.variableNames = ["A", "B"], this.uniforms = "dimAOuter : i32, dimBOuter : i32, dimInner : i32,", this.workgroupSize = [8, 8, 1], this.atomic = !0, this.splitedDimInner = 128, w(t[0] === 1, () => "MatMulSplitKProgram only supports batch = 1."), this.outputShape = t, this.dispatchLayout = { x: [2], y: [1], z: [0, 3] };
     const o = (s && this.outputShape[1] % 4 === 0 || !s && e % 4 === 0) && this.outputShape[2] % 4 === 0;
-    this.elementsPerThread = [4, 4, this.splitedDimInner], this.outputComponent = o ? 4 : 1, o || (this.outputShape[1] < 16 && (this.elementsPerThread[1] = 1), this.outputShape[2] < 16 && (this.elementsPerThread[0] = 1)), this.dispatch = It(this.dispatchLayout, [
+    this.elementsPerThread = [4, 4, this.splitedDimInner], this.outputComponent = o ? 4 : 1, o || (this.outputShape[1] < 16 && (this.elementsPerThread[1] = 1), this.outputShape[2] < 16 && (this.elementsPerThread[0] = 1)), this.dispatch = $t(this.dispatchLayout, [
       this.outputShape[0],
       this.outputShape[1],
       this.outputShape[2],
@@ -21879,7 +21879,7 @@ class jv {
 }
 class Hv {
   constructor(t, e = null, s = null, r = null) {
-    this.uniforms = "", this.variableNames = ["x"], this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = t, this.dispatchLayout = ae(this.outputShape), this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize), this.addBias = e != null, this.hasPreluActivationWeights = r != null, this.activation = s, this.addBias && this.variableNames.push("bias"), this.hasPreluActivationWeights && this.variableNames.push("preluActivationWeights"), this.shaderKey = `biasActivation_${s}`;
+    this.uniforms = "", this.variableNames = ["x"], this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = t, this.dispatchLayout = ae(this.outputShape), this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize), this.addBias = e != null, this.hasPreluActivationWeights = r != null, this.activation = s, this.addBias && this.variableNames.push("bias"), this.hasPreluActivationWeights && this.variableNames.push("preluActivationWeights"), this.shaderKey = `biasActivation_${s}`;
   }
   getUserCode() {
     return `
@@ -22218,7 +22218,7 @@ const Zv = {
  */
 class Qv {
   constructor(t) {
-    this.variableNames = ["x"], this.uniforms = "strides : vec2<i32>,", this.workgroupSize = [256, 1, 1], this.size = !0, this.outputShape = t.outShape, this.dispatchLayout = ae(this.outputShape), this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize), this.shaderKey = "poolWithFilterSizeEqualsOne";
+    this.variableNames = ["x"], this.uniforms = "strides : vec2<i32>,", this.workgroupSize = [256, 1, 1], this.size = !0, this.outputShape = t.outShape, this.dispatchLayout = ae(this.outputShape), this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize), this.shaderKey = "poolWithFilterSizeEqualsOne";
   }
   getUserCode() {
     return `
@@ -22255,11 +22255,11 @@ class Qv {
  * limitations under the License.
  * =============================================================================
  */
-class t$ {
+class tI {
   constructor(t, e, s = !1, r = !1, o = !1) {
     if (this.variableNames = ["x"], this.uniforms = "strides : vec2<i32>, pads : vec2<i32>, dilations : vec2<i32>, convDims : vec2<i32>, filterDims : vec2<i32>,", this.workgroupSize = [128, 1, 1], this.size = !0, e === "avg" && s)
       throw new Error("Cannot compute positions for average pool.");
-    this.outputShape = t.outShape, this.dispatchLayout = ae(this.outputShape), this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize), this.poolType = e, this.computePositions = s, this.flattenPositions = r, this.includeBatchIndex = o, this.shaderKey = `pool2D_${e}_${s}_${r}_${o}`;
+    this.outputShape = t.outShape, this.dispatchLayout = ae(this.outputShape), this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize), this.poolType = e, this.computePositions = s, this.flattenPositions = r, this.includeBatchIndex = o, this.shaderKey = `pool2D_${e}_${s}_${r}_${o}`;
   }
   getUserCode() {
     let t;
@@ -22325,13 +22325,13 @@ class t$ {
  * limitations under the License.
  * =============================================================================
  */
-class e$ {
+class eI {
   constructor(t, e) {
     this.variableNames = ["A"], this.workgroupSize = [16, 16, 1];
     const s = new Array(t.length);
     for (let r = 0; r < s.length; r++)
       s[r] = t[e[r]];
-    this.outputShape = s, this.dispatchLayout = { x: [0], y: [1] }, this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize, [1, 1, 1]), this.shaderKey = "transposeShared";
+    this.outputShape = s, this.dispatchLayout = { x: [0], y: [1] }, this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize, [1, 1, 1]), this.shaderKey = "transposeShared";
   }
   getUserCode() {
     w(this.workgroupSize[0] === this.workgroupSize[1], () => `Must be a square tile, current tile shape is ${this.workgroupSize[0]} x ${this.workgroupSize[1]}`);
@@ -22374,16 +22374,16 @@ class e$ {
  * limitations under the License.
  * =============================================================================
  */
-class n$ {
+class nI {
   constructor(t, e) {
     this.variableNames = ["A"], this.workPerThread = 1, this.workgroupSize = [64, 1, 1], this.size = !0;
     const s = new Array(t.length);
     for (let r = 0; r < s.length; r++)
       s[r] = t[e[r]];
-    this.outputShape = s, this.dispatchLayout = ae(this.outputShape), this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize, [this.workPerThread, 1, 1]), this.newDim = e, this.shaderKey = `transpose_${e}`;
+    this.outputShape = s, this.dispatchLayout = ae(this.outputShape), this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize, [this.workPerThread, 1, 1]), this.newDim = e, this.shaderKey = `transpose_${e}`;
   }
   getUserCode() {
-    const t = Tt(this.outputShape.length), e = s$(this.newDim);
+    const t = Tt(this.outputShape.length), e = sI(this.newDim);
     return `
       ${wt("index")} {
         for(var i = 0; i < ${this.workPerThread}; i = i + 1) {
@@ -22398,7 +22398,7 @@ class n$ {
     `;
   }
 }
-function s$(n) {
+function sI(n) {
   const t = n.length;
   if (t > 6)
     throw Error(`Transpose for rank ${t} is not yet supported`);
@@ -22423,7 +22423,7 @@ function s$(n) {
  * limitations under the License.
  * =============================================================================
  */
-function r$(n) {
+function rI(n) {
   const { inputs: t, backend: e, attrs: s } = n, { x: r } = t, { perm: o } = s, i = e, a = r.shape.length, l = new Array(a);
   for (let c = 0; c < l.length; c++)
     l[c] = r.shape[o[c]];
@@ -22432,10 +22432,10 @@ function r$(n) {
     return e.makeTensorInfo(l, r.dtype, f);
   }
   if (r.shape.length === 2 && oe(o, [1, 0])) {
-    const c = new e$(r.shape, o);
+    const c = new eI(r.shape, o);
     return i.runWebGPUProgram(c, [r], r.dtype);
   }
-  const u = new n$(r.shape, o);
+  const u = new nI(r.shape, o);
   return i.runWebGPUProgram(u, [r], r.dtype);
 }
 /**
@@ -22454,11 +22454,11 @@ function r$(n) {
  * limitations under the License.
  * =============================================================================
  */
-class o$ {
+class oI {
   constructor(t, e, s) {
     this.variableNames = ["x"], this.uniforms = "reduceSize : i32,", this.size = !0, this.inputShape = [t.batchSize, t.inSize];
     const [r] = bi(this.inputShape, [1]);
-    this.outputShape = r.length === 0 ? [1] : r, t.inSize >= 32768 && s >= 512 ? this.workgroupSize = [512, 1, 1] : t.inSize >= 4096 ? this.workgroupSize = [256, 1, 1] : this.workgroupSize = [64, 1, 1], this.dispatchLayout = ae(this.outputShape), this.dispatch = It(this.dispatchLayout, this.outputShape, [1, 1, 1]), this.reduceType = e, this.shaderKey = `reduce_${e}`;
+    this.outputShape = r.length === 0 ? [1] : r, t.inSize >= 32768 && s >= 512 ? this.workgroupSize = [512, 1, 1] : t.inSize >= 4096 ? this.workgroupSize = [256, 1, 1] : this.workgroupSize = [64, 1, 1], this.dispatchLayout = ae(this.outputShape), this.dispatch = $t(this.dispatchLayout, this.outputShape, [1, 1, 1]), this.reduceType = e, this.shaderKey = `reduce_${e}`;
   }
   getUserCode() {
     let t = "", e = "0.0";
@@ -22535,17 +22535,17 @@ class o$ {
  * limitations under the License.
  * =============================================================================
  */
-const i$ = {
+const iI = {
   mean: "float32",
   all: "bool",
   any: "bool"
 };
-function a$(n, t, e, s, r) {
+function aI(n, t, e, s, r) {
   const o = n.shape.length, i = [], a = _s(t, n.shape);
   let l = a;
   const u = gg(l, o);
   let c = n;
-  u != null && (c = r$({ inputs: { x: n }, attrs: { perm: u }, backend: r }), l = bg(l.length, o), i.push(c)), mg(s, l, o);
+  u != null && (c = rI({ inputs: { x: n }, attrs: { perm: u }, backend: r }), l = bg(l.length, o), i.push(c)), mg(s, l, o);
   const [h, f] = bi(c.shape, l);
   let d = h;
   e && (d = _u(h, a));
@@ -22565,9 +22565,9 @@ function a$(n, t, e, s, r) {
         throw new Error(`${s} CPU implementation is not yet supported.`);
     }
   } else {
-    const g = z(f), b = z(c.shape) / g, y = { windowSize: g, inSize: g, batchSize: b, outSize: 1 }, S = i$[s] || Dp(n.dtype), x = [
+    const g = z(f), b = z(c.shape) / g, y = { windowSize: g, inSize: g, batchSize: b, outSize: 1 }, S = iI[s] || Dp(n.dtype), x = [
       { type: "int32", data: [g] }
-    ], v = new o$(y, s, r.device.limits.maxComputeWorkgroupSizeX), E = r.runWebGPUProgram(v, [c], S, x);
+    ], v = new oI(y, s, r.device.limits.maxComputeWorkgroupSizeX), E = r.runWebGPUProgram(v, [c], S, x);
     i.push(E), p = dt({ inputs: { x: E }, attrs: { shape: d }, backend: r });
   }
   return i.forEach((g) => r.disposeData(g.dataId)), p;
@@ -22588,9 +22588,9 @@ function a$(n, t, e, s, r) {
  * limitations under the License.
  * =============================================================================
  */
-function l$(n) {
+function lI(n) {
   const { inputs: t, backend: e, attrs: s } = n, { x: r } = t, { reductionIndices: o, keepDims: i } = s;
-  return a$(r, o, i, "max", e);
+  return aI(r, o, i, "max", e);
 }
 /**
  * @license
@@ -22608,7 +22608,7 @@ function l$(n) {
  * limitations under the License.
  * =============================================================================
  */
-function u$(n, t, e, s) {
+function uI(n, t, e, s) {
   if (t.filterWidth === 1 && t.filterHeight === 1 && oe(t.inShape, t.outShape))
     return He({ inputs: { x: n }, backend: s });
   if (t.filterWidth === t.inWidth && t.filterHeight === t.inHeight && t.batchSize === 1 && t.padInfo.type === "VALID") {
@@ -22624,7 +22624,7 @@ function u$(n, t, e, s) {
       }
     });
     let l;
-    w(e === "max", () => `Invalid pool type ${e}`), l = l$({
+    w(e === "max", () => `Invalid pool type ${e}`), l = lI({
       inputs: { x: a },
       backend: s,
       attrs: { reductionIndices: 0, keepDims: !1 }
@@ -22634,7 +22634,7 @@ function u$(n, t, e, s) {
   }
   let r;
   const o = [{ type: "int32", data: [t.strideHeight, t.strideWidth] }];
-  return t.filterHeight === 1 && t.filterWidth === 1 ? r = new Qv(t) : (w(e === "max", () => `Invalid pool type ${e}`), r = new t$(t, "max"), o.push({ type: "int32", data: [t.padInfo.top, t.padInfo.left] }, {
+  return t.filterHeight === 1 && t.filterWidth === 1 ? r = new Qv(t) : (w(e === "max", () => `Invalid pool type ${e}`), r = new tI(t, "max"), o.push({ type: "int32", data: [t.padInfo.top, t.padInfo.left] }, {
     type: "int32",
     data: [t.dilationHeight, t.dilationWidth]
   }, { type: "int32", data: [t.inHeight, t.inWidth] }, {
@@ -22658,14 +22658,14 @@ function u$(n, t, e, s) {
  * limitations under the License.
  * =============================================================================
  */
-function c$(n) {
+function cI(n) {
   const { inputs: t, backend: e, attrs: s } = n, { x: r } = t, { filterSize: o, strides: i, pad: a, dimRoundingMode: l } = s, c = km(r.shape, o, i, 1, a, l);
-  return u$(r, c, "max", e);
+  return uI(r, c, "max", e);
 }
-const h$ = {
+const hI = {
   kernelName: Hl,
   backendName: "webgpu",
-  kernelFunc: c$
+  kernelFunc: cI
 };
 /**
  * @license
@@ -22683,9 +22683,9 @@ const h$ = {
  * limitations under the License.
  * =============================================================================
  */
-class f$ {
+class fI {
   constructor(t, e, s, r) {
-    this.variableNames = ["x"], this.uniforms = "adjustHeightWidth : vec2<f32>, roundBase : f32,", this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = [t[0], e, s, t[3]], this.dispatchLayout = ae(this.outputShape), this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize), this.halfPixelCenters = r, this.shaderKey = `resizeNearest_${r}`;
+    this.variableNames = ["x"], this.uniforms = "adjustHeightWidth : vec2<f32>, roundBase : f32,", this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = [t[0], e, s, t[3]], this.dispatchLayout = ae(this.outputShape), this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize), this.halfPixelCenters = r, this.shaderKey = `resizeNearest_${r}`;
   }
   getUserCode() {
     let t;
@@ -22739,17 +22739,17 @@ class f$ {
  * limitations under the License.
  * =============================================================================
  */
-function d$(n) {
+function dI(n) {
   const { inputs: t, backend: e, attrs: s } = n, { images: r } = t, { alignCorners: o, halfPixelCenters: i, size: a } = s, [l, u] = a, c = o && l > 1 ? 1 : 0, h = o && u > 1 ? 1 : 0, d = [
     { type: "float32", data: [c, h] },
     { type: "float32", data: [o ? 0.5 : 0] }
-  ], p = new f$(r.shape, l, u, i);
+  ], p = new fI(r.shape, l, u, i);
   return e.runWebGPUProgram(p, [r], r.dtype, d);
 }
-const p$ = {
+const pI = {
   kernelName: Yl,
   backendName: "webgpu",
-  kernelFunc: d$
+  kernelFunc: dI
 };
 /**
  * @license
@@ -22767,13 +22767,13 @@ const p$ = {
  * limitations under the License.
  * =============================================================================
  */
-class m$ {
+class mI {
   constructor(t) {
     this.uniforms = "", this.workPerThread = 1, this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = Ss(
       t,
       1
       /* axis */
-    ), this.variableNames = t.map((e, s) => `T${s}`), this.dispatchLayout = ae(this.outputShape), this.dispatch = It(this.dispatchLayout, this.outputShape, this.workgroupSize, [this.workPerThread, 1, 1]), this.offsetLength = t.length - 1;
+    ), this.variableNames = t.map((e, s) => `T${s}`), this.dispatchLayout = ae(this.outputShape), this.dispatch = $t(this.dispatchLayout, this.outputShape, this.workgroupSize, [this.workPerThread, 1, 1]), this.offsetLength = t.length - 1;
     for (let e = 0; e < this.offsetLength; e++)
       this.uniforms += `offset${e} : i32,`;
     this.shaderKey = "concat";
@@ -22821,7 +22821,7 @@ class m$ {
  * limitations under the License.
  * =============================================================================
  */
-function g$(n) {
+function gI(n) {
   const { inputs: t, backend: e } = n, { real: s, imag: r } = t, o = e.makeTensorInfo(s.shape, "complex64"), i = e.tensorMap.get(o.dataId), a = He({ inputs: { x: s }, backend: e }), l = He({ inputs: { x: r }, backend: e });
   return i.complexTensorInfos = { real: a, imag: l }, o;
 }
@@ -22841,7 +22841,7 @@ function g$(n) {
  * limitations under the License.
  * =============================================================================
  */
-function b$(n) {
+function bI(n) {
   const { inputs: t, backend: e } = n, { input: s } = t, r = e.tensorMap.get(s.dataId);
   return He({ inputs: { x: r.complexTensorInfos.imag }, backend: e });
 }
@@ -22861,7 +22861,7 @@ function b$(n) {
  * limitations under the License.
  * =============================================================================
  */
-function y$(n) {
+function yI(n) {
   const { inputs: t, backend: e } = n, { input: s } = t, r = e.tensorMap.get(s.dataId);
   return He({ inputs: { x: r.complexTensorInfos.real }, backend: e });
 }
@@ -22884,7 +22884,7 @@ function y$(n) {
 function ds(n, t, e) {
   const s = n[0].dtype;
   if (s === "complex64") {
-    const p = n.map((S) => y$({ inputs: { input: S }, backend: e })), g = n.map((S) => b$({ inputs: { input: S }, backend: e })), m = ds(p, t, e), b = ds(g, t, e), y = g$({ inputs: { real: m, imag: b }, backend: e });
+    const p = n.map((S) => yI({ inputs: { input: S }, backend: e })), g = n.map((S) => bI({ inputs: { input: S }, backend: e })), m = ds(p, t, e), b = ds(g, t, e), y = gI({ inputs: { real: m, imag: b }, backend: e });
     return p.forEach((S) => e.disposeData(S.dataId)), g.forEach((S) => e.disposeData(S.dataId)), e.disposeData(m.dataId), e.disposeData(b.dataId), y;
   }
   let r = e.shouldExecuteOnCPU(n);
@@ -22911,7 +22911,7 @@ function ds(n, t, e) {
       e.disposeData(m.dataId);
     return g;
   }
-  const { tensors2D: i, outShape: a } = w$(n, t, e), l = i.map((p) => p.shape), u = new m$(l), c = [], h = new Array(l.length - 1);
+  const { tensors2D: i, outShape: a } = wI(n, t, e), l = i.map((p) => p.shape), u = new mI(l), c = [], h = new Array(l.length - 1);
   if (h.length > 0) {
     h[0] = l[0][1], c.push({ type: "int32", data: [h[0]] });
     for (let p = 1; p < h.length; p++)
@@ -22922,7 +22922,7 @@ function ds(n, t, e) {
   const d = dt({ inputs: { x: f }, backend: e, attrs: { shape: a } });
   return e.disposeData(f.dataId), d;
 }
-function w$(n, t, e) {
+function wI(n, t, e) {
   const s = Ss(n.map((o) => o.shape), t);
   return { tensors2D: n.map((o) => dt({
     inputs: { x: o },
@@ -22951,7 +22951,7 @@ function w$(n, t, e) {
  * limitations under the License.
  * =============================================================================
  */
-function x$(n) {
+function xI(n) {
   const { inputs: t, backend: e, attrs: s } = n, { axis: r } = s, o = _s(r, t[0].shape)[0], i = t.map((u) => u.shape);
   hy(i, o);
   const a = Ss(t.map((u) => u.shape), o);
@@ -22960,26 +22960,26 @@ function x$(n) {
   const l = t.filter((u) => z(u.shape) > 0);
   return l.length === 1 ? He({ inputs: { x: l[0] }, backend: e }) : ds(l, o, e);
 }
-const S$ = {
+const SI = {
   kernelName: jl,
   backendName: "webgpu",
-  kernelFunc: x$
-}, v$ = [
+  kernelFunc: xI
+}, vI = [
   Vx,
   Xx,
   c2,
   Zv,
-  h$,
-  p$,
-  S$,
+  hI,
+  pI,
+  SI,
   qx
 ];
-for (const n of v$)
+for (const n of vI)
   up({
     ...n,
     backendName: "webgpu-oidn"
   });
-async function $$() {
+async function II() {
   var n;
   try {
     const t = {
@@ -23008,19 +23008,19 @@ async function hf(n, t) {
   let e = A.findBackend("webgpu-oidn");
   return e != null || (e = new Fs(n, t), A.registerBackend("webgpu-oidn", () => e), await A.setBackend("webgpu-oidn")), e;
 }
-async function I$(n, t, e) {
+async function $I(n, t, e) {
   const s = await (t ? hf(
     t.device,
     t.adapterInfo
-  ) : $$()), r = xf(n);
+  ) : II()), r = xf(n);
   return new xx(r, s, e);
 }
-async function nI(n, t, e) {
-  return fetch(n).then((s) => s.arrayBuffer()).then((s) => I$(s, t, e));
+async function n$(n, t, e) {
+  return fetch(n).then((s) => s.arrayBuffer()).then((s) => $I(s, t, e));
 }
 export {
   xx as UNet,
-  I$ as initUNetFromBuffer,
-  nI as initUNetFromURL,
+  $I as initUNetFromBuffer,
+  n$ as initUNetFromURL,
   xf as parseTZA
 };