@genai-fi/nanogpt 0.5.6 → 0.6.0

package/dist/shared-XNAoXhOa.js

@@ -0,0 +1,2826 @@
+import { q as $, Q as yt, ac as Y, b1 as nt, b2 as dt, b3 as gt, b4 as ht, b5 as Lt, Z as rt, ak as k, b6 as q, b7 as Mt, U as Nt, l as $t, t as At, b8 as ct, an as ut, b9 as tt, a1 as Dt } from "./index-bMBtI-WR.js";
+import { f as bt, c as Pt } from "./kernel_funcs_utils-CNmjLWnB.js";
+import { c as Wt } from "./axis_util-D17qZRQm.js";
+import { b as qt } from "./broadcast_to-BMQLjvt_.js";
+import { r as Vt } from "./reshape-T4yDEqoF.js";
+import { i as Ut, c as zt } from "./slice_util-Ddk0uxGJ.js";
+import { g as Gt } from "./_commonjsHelpers-ByX85dGu.js";
+function jt(e, t) {
+  for (var n = 0; n < t.length; n++) {
+    const r = t[n];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const o in r)
+        if (o !== "default" && !(o in e)) {
+          const s = Object.getOwnPropertyDescriptor(r, o);
+          s && Object.defineProperty(e, o, s.get ? s : {
+            enumerable: !0,
+            get: () => r[o]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var at, mt;
+function Zt() {
+  if (mt) return at;
+  mt = 1, at = t;
+  var e = null;
+  try {
+    e = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([
+      0,
+      97,
+      115,
+      109,
+      1,
+      0,
+      0,
+      0,
+      1,
+      13,
+      2,
+      96,
+      0,
+      1,
+      127,
+      96,
+      4,
+      127,
+      127,
+      127,
+      127,
+      1,
+      127,
+      3,
+      7,
+      6,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1,
+      6,
+      6,
+      1,
+      127,
+      1,
+      65,
+      0,
+      11,
+      7,
+      50,
+      6,
+      3,
+      109,
+      117,
+      108,
+      0,
+      1,
+      5,
+      100,
+      105,
+      118,
+      95,
+      115,
+      0,
+      2,
+      5,
+      100,
+      105,
+      118,
+      95,
+      117,
+      0,
+      3,
+      5,
+      114,
+      101,
+      109,
+      95,
+      115,
+      0,
+      4,
+      5,
+      114,
+      101,
+      109,
+      95,
+      117,
+      0,
+      5,
+      8,
+      103,
+      101,
+      116,
+      95,
+      104,
+      105,
+      103,
+      104,
+      0,
+      0,
+      10,
+      191,
+      1,
+      6,
+      4,
+      0,
+      35,
+      0,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      126,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      127,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      128,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      129,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11,
+      36,
+      1,
+      1,
+      126,
+      32,
+      0,
+      173,
+      32,
+      1,
+      173,
+      66,
+      32,
+      134,
+      132,
+      32,
+      2,
+      173,
+      32,
+      3,
+      173,
+      66,
+      32,
+      134,
+      132,
+      130,
+      34,
+      4,
+      66,
+      32,
+      135,
+      167,
+      36,
+      0,
+      32,
+      4,
+      167,
+      11
+    ])), {}).exports;
+  } catch {
+  }
+  function t(w, l, F) {
+    this.low = w | 0, this.high = l | 0, this.unsigned = !!F;
+  }
+  t.prototype.__isLong__, Object.defineProperty(t.prototype, "__isLong__", { value: !0 });
+  function n(w) {
+    return (w && w.__isLong__) === !0;
+  }
+  t.isLong = n;
+  var r = {}, o = {};
+  function s(w, l) {
+    var F, T, _;
+    return l ? (w >>>= 0, (_ = 0 <= w && w < 256) && (T = o[w], T) ? T : (F = u(w, (w | 0) < 0 ? -1 : 0, !0), _ && (o[w] = F), F)) : (w |= 0, (_ = -128 <= w && w < 128) && (T = r[w], T) ? T : (F = u(w, w < 0 ? -1 : 0, !1), _ && (r[w] = F), F));
+  }
+  t.fromInt = s;
+  function i(w, l) {
+    if (isNaN(w))
+      return l ? E : d;
+    if (l) {
+      if (w < 0)
+        return E;
+      if (w >= m)
+        return z;
+    } else {
+      if (w <= -b)
+        return L;
+      if (w + 1 >= b)
+        return V;
+    }
+    return w < 0 ? i(-w, l).neg() : u(w % I | 0, w / I | 0, l);
+  }
+  t.fromNumber = i;
+  function u(w, l, F) {
+    return new t(w, l, F);
+  }
+  t.fromBits = u;
+  var a = Math.pow;
+  function h(w, l, F) {
+    if (w.length === 0)
+      throw Error("empty string");
+    if (w === "NaN" || w === "Infinity" || w === "+Infinity" || w === "-Infinity")
+      return d;
+    if (typeof l == "number" ? (F = l, l = !1) : l = !!l, F = F || 10, F < 2 || 36 < F)
+      throw RangeError("radix");
+    var T;
+    if ((T = w.indexOf("-")) > 0)
+      throw Error("interior hyphen");
+    if (T === 0)
+      return h(w.substring(1), l, F).neg();
+    for (var _ = i(a(F, 8)), O = d, M = 0; M < w.length; M += 8) {
+      var G = Math.min(8, w.length - M), Z = parseInt(w.substring(M, M + G), F);
+      if (G < 8) {
+        var P = i(a(F, G));
+        O = O.mul(P).add(i(Z));
+      } else
+        O = O.mul(_), O = O.add(i(Z));
+    }
+    return O.unsigned = l, O;
+  }
+  t.fromString = h;
+  function c(w, l) {
+    return typeof w == "number" ? i(w, l) : typeof w == "string" ? h(w, l) : u(w.low, w.high, typeof l == "boolean" ? l : w.unsigned);
+  }
+  t.fromValue = c;
+  var f = 65536, p = 1 << 24, I = f * f, m = I * I, b = m / 2, g = s(p), d = s(0);
+  t.ZERO = d;
+  var E = s(0, !0);
+  t.UZERO = E;
+  var R = s(1);
+  t.ONE = R;
+  var x = s(1, !0);
+  t.UONE = x;
+  var D = s(-1);
+  t.NEG_ONE = D;
+  var V = u(-1, 2147483647, !1);
+  t.MAX_VALUE = V;
+  var z = u(-1, -1, !0);
+  t.MAX_UNSIGNED_VALUE = z;
+  var L = u(0, -2147483648, !1);
+  t.MIN_VALUE = L;
+  var S = t.prototype;
+  return S.toInt = function() {
+    return this.unsigned ? this.low >>> 0 : this.low;
+  }, S.toNumber = function() {
+    return this.unsigned ? (this.high >>> 0) * I + (this.low >>> 0) : this.high * I + (this.low >>> 0);
+  }, S.toString = function(l) {
+    if (l = l || 10, l < 2 || 36 < l)
+      throw RangeError("radix");
+    if (this.isZero())
+      return "0";
+    if (this.isNegative())
+      if (this.eq(L)) {
+        var F = i(l), T = this.div(F), _ = T.mul(F).sub(this);
+        return T.toString(l) + _.toInt().toString(l);
+      } else
+        return "-" + this.neg().toString(l);
+    for (var O = i(a(l, 6), this.unsigned), M = this, G = ""; ; ) {
+      var Z = M.div(O), P = M.sub(Z.mul(O)).toInt() >>> 0, y = P.toString(l);
+      if (M = Z, M.isZero())
+        return y + G;
+      for (; y.length < 6; )
+        y = "0" + y;
+      G = "" + y + G;
+    }
+  }, S.getHighBits = function() {
+    return this.high;
+  }, S.getHighBitsUnsigned = function() {
+    return this.high >>> 0;
+  }, S.getLowBits = function() {
+    return this.low;
+  }, S.getLowBitsUnsigned = function() {
+    return this.low >>> 0;
+  }, S.getNumBitsAbs = function() {
+    if (this.isNegative())
+      return this.eq(L) ? 64 : this.neg().getNumBitsAbs();
+    for (var l = this.high != 0 ? this.high : this.low, F = 31; F > 0 && (l & 1 << F) == 0; F--)
+      ;
+    return this.high != 0 ? F + 33 : F + 1;
+  }, S.isZero = function() {
+    return this.high === 0 && this.low === 0;
+  }, S.eqz = S.isZero, S.isNegative = function() {
+    return !this.unsigned && this.high < 0;
+  }, S.isPositive = function() {
+    return this.unsigned || this.high >= 0;
+  }, S.isOdd = function() {
+    return (this.low & 1) === 1;
+  }, S.isEven = function() {
+    return (this.low & 1) === 0;
+  }, S.equals = function(l) {
+    return n(l) || (l = c(l)), this.unsigned !== l.unsigned && this.high >>> 31 === 1 && l.high >>> 31 === 1 ? !1 : this.high === l.high && this.low === l.low;
+  }, S.eq = S.equals, S.notEquals = function(l) {
+    return !this.eq(
+      /* validates */
+      l
+    );
+  }, S.neq = S.notEquals, S.ne = S.notEquals, S.lessThan = function(l) {
+    return this.comp(
+      /* validates */
+      l
+    ) < 0;
+  }, S.lt = S.lessThan, S.lessThanOrEqual = function(l) {
+    return this.comp(
+      /* validates */
+      l
+    ) <= 0;
+  }, S.lte = S.lessThanOrEqual, S.le = S.lessThanOrEqual, S.greaterThan = function(l) {
+    return this.comp(
+      /* validates */
+      l
+    ) > 0;
+  }, S.gt = S.greaterThan, S.greaterThanOrEqual = function(l) {
+    return this.comp(
+      /* validates */
+      l
+    ) >= 0;
+  }, S.gte = S.greaterThanOrEqual, S.ge = S.greaterThanOrEqual, S.compare = function(l) {
+    if (n(l) || (l = c(l)), this.eq(l))
+      return 0;
+    var F = this.isNegative(), T = l.isNegative();
+    return F && !T ? -1 : !F && T ? 1 : this.unsigned ? l.high >>> 0 > this.high >>> 0 || l.high === this.high && l.low >>> 0 > this.low >>> 0 ? -1 : 1 : this.sub(l).isNegative() ? -1 : 1;
+  }, S.comp = S.compare, S.negate = function() {
+    return !this.unsigned && this.eq(L) ? L : this.not().add(R);
+  }, S.neg = S.negate, S.add = function(l) {
+    n(l) || (l = c(l));
+    var F = this.high >>> 16, T = this.high & 65535, _ = this.low >>> 16, O = this.low & 65535, M = l.high >>> 16, G = l.high & 65535, Z = l.low >>> 16, P = l.low & 65535, y = 0, C = 0, A = 0, j = 0;
+    return j += O + P, A += j >>> 16, j &= 65535, A += _ + Z, C += A >>> 16, A &= 65535, C += T + G, y += C >>> 16, C &= 65535, y += F + M, y &= 65535, u(A << 16 | j, y << 16 | C, this.unsigned);
+  }, S.subtract = function(l) {
+    return n(l) || (l = c(l)), this.add(l.neg());
+  }, S.sub = S.subtract, S.multiply = function(l) {
+    if (this.isZero())
+      return d;
+    if (n(l) || (l = c(l)), e) {
+      var F = e.mul(
+        this.low,
+        this.high,
+        l.low,
+        l.high
+      );
+      return u(F, e.get_high(), this.unsigned);
+    }
+    if (l.isZero())
+      return d;
+    if (this.eq(L))
+      return l.isOdd() ? L : d;
+    if (l.eq(L))
+      return this.isOdd() ? L : d;
+    if (this.isNegative())
+      return l.isNegative() ? this.neg().mul(l.neg()) : this.neg().mul(l).neg();
+    if (l.isNegative())
+      return this.mul(l.neg()).neg();
+    if (this.lt(g) && l.lt(g))
+      return i(this.toNumber() * l.toNumber(), this.unsigned);
+    var T = this.high >>> 16, _ = this.high & 65535, O = this.low >>> 16, M = this.low & 65535, G = l.high >>> 16, Z = l.high & 65535, P = l.low >>> 16, y = l.low & 65535, C = 0, A = 0, j = 0, ot = 0;
+    return ot += M * y, j += ot >>> 16, ot &= 65535, j += O * y, A += j >>> 16, j &= 65535, j += M * P, A += j >>> 16, j &= 65535, A += _ * y, C += A >>> 16, A &= 65535, A += O * P, C += A >>> 16, A &= 65535, A += M * Z, C += A >>> 16, A &= 65535, C += T * y + _ * P + O * Z + M * G, C &= 65535, u(j << 16 | ot, C << 16 | A, this.unsigned);
+  }, S.mul = S.multiply, S.divide = function(l) {
+    if (n(l) || (l = c(l)), l.isZero())
+      throw Error("division by zero");
+    if (e) {
+      if (!this.unsigned && this.high === -2147483648 && l.low === -1 && l.high === -1)
+        return this;
+      var F = (this.unsigned ? e.div_u : e.div_s)(
+        this.low,
+        this.high,
+        l.low,
+        l.high
+      );
+      return u(F, e.get_high(), this.unsigned);
+    }
+    if (this.isZero())
+      return this.unsigned ? E : d;
+    var T, _, O;
+    if (this.unsigned) {
+      if (l.unsigned || (l = l.toUnsigned()), l.gt(this))
+        return E;
+      if (l.gt(this.shru(1)))
+        return x;
+      O = E;
+    } else {
+      if (this.eq(L)) {
+        if (l.eq(R) || l.eq(D))
+          return L;
+        if (l.eq(L))
+          return R;
+        var M = this.shr(1);
+        return T = M.div(l).shl(1), T.eq(d) ? l.isNegative() ? R : D : (_ = this.sub(l.mul(T)), O = T.add(_.div(l)), O);
+      } else if (l.eq(L))
+        return this.unsigned ? E : d;
+      if (this.isNegative())
+        return l.isNegative() ? this.neg().div(l.neg()) : this.neg().div(l).neg();
+      if (l.isNegative())
+        return this.div(l.neg()).neg();
+      O = d;
+    }
+    for (_ = this; _.gte(l); ) {
+      T = Math.max(1, Math.floor(_.toNumber() / l.toNumber()));
+      for (var G = Math.ceil(Math.log(T) / Math.LN2), Z = G <= 48 ? 1 : a(2, G - 48), P = i(T), y = P.mul(l); y.isNegative() || y.gt(_); )
+        T -= Z, P = i(T, this.unsigned), y = P.mul(l);
+      P.isZero() && (P = R), O = O.add(P), _ = _.sub(y);
+    }
+    return O;
+  }, S.div = S.divide, S.modulo = function(l) {
+    if (n(l) || (l = c(l)), e) {
+      var F = (this.unsigned ? e.rem_u : e.rem_s)(
+        this.low,
+        this.high,
+        l.low,
+        l.high
+      );
+      return u(F, e.get_high(), this.unsigned);
+    }
+    return this.sub(this.div(l).mul(l));
+  }, S.mod = S.modulo, S.rem = S.modulo, S.not = function() {
+    return u(~this.low, ~this.high, this.unsigned);
+  }, S.and = function(l) {
+    return n(l) || (l = c(l)), u(this.low & l.low, this.high & l.high, this.unsigned);
+  }, S.or = function(l) {
+    return n(l) || (l = c(l)), u(this.low | l.low, this.high | l.high, this.unsigned);
+  }, S.xor = function(l) {
+    return n(l) || (l = c(l)), u(this.low ^ l.low, this.high ^ l.high, this.unsigned);
+  }, S.shiftLeft = function(l) {
+    return n(l) && (l = l.toInt()), (l &= 63) === 0 ? this : l < 32 ? u(this.low << l, this.high << l | this.low >>> 32 - l, this.unsigned) : u(0, this.low << l - 32, this.unsigned);
+  }, S.shl = S.shiftLeft, S.shiftRight = function(l) {
+    return n(l) && (l = l.toInt()), (l &= 63) === 0 ? this : l < 32 ? u(this.low >>> l | this.high << 32 - l, this.high >> l, this.unsigned) : u(this.high >> l - 32, this.high >= 0 ? 0 : -1, this.unsigned);
+  }, S.shr = S.shiftRight, S.shiftRightUnsigned = function(l) {
+    if (n(l) && (l = l.toInt()), l &= 63, l === 0)
+      return this;
+    var F = this.high;
+    if (l < 32) {
+      var T = this.low;
+      return u(T >>> l | F << 32 - l, F >>> l, this.unsigned);
+    } else return l === 32 ? u(F, 0, this.unsigned) : u(F >>> l - 32, 0, this.unsigned);
+  }, S.shru = S.shiftRightUnsigned, S.shr_u = S.shiftRightUnsigned, S.toSigned = function() {
+    return this.unsigned ? u(this.low, this.high, !1) : this;
+  }, S.toUnsigned = function() {
+    return this.unsigned ? this : u(this.low, this.high, !0);
+  }, S.toBytes = function(l) {
+    return l ? this.toBytesLE() : this.toBytesBE();
+  }, S.toBytesLE = function() {
+    var l = this.high, F = this.low;
+    return [
+      F & 255,
+      F >>> 8 & 255,
+      F >>> 16 & 255,
+      F >>> 24,
+      l & 255,
+      l >>> 8 & 255,
+      l >>> 16 & 255,
+      l >>> 24
+    ];
+  }, S.toBytesBE = function() {
+    var l = this.high, F = this.low;
+    return [
+      l >>> 24,
+      l >>> 16 & 255,
+      l >>> 8 & 255,
+      l & 255,
+      F >>> 24,
+      F >>> 16 & 255,
+      F >>> 8 & 255,
+      F & 255
+    ];
+  }, t.fromBytes = function(l, F, T) {
+    return T ? t.fromBytesLE(l, F) : t.fromBytesBE(l, F);
+  }, t.fromBytesLE = function(l, F) {
+    return new t(
+      l[0] | l[1] << 8 | l[2] << 16 | l[3] << 24,
+      l[4] | l[5] << 8 | l[6] << 16 | l[7] << 24,
+      F
+    );
+  }, t.fromBytesBE = function(l, F) {
+    return new t(
+      l[4] << 24 | l[5] << 16 | l[6] << 8 | l[7],
+      l[0] << 24 | l[1] << 16 | l[2] << 8 | l[3],
+      F
+    );
+  }, at;
+}
+var xt = Zt();
+const Rt = /* @__PURE__ */ Gt(xt), Ct = /* @__PURE__ */ jt({
+  __proto__: null,
+  default: Rt
+}, [xt]);
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const J = (
+  // tslint:disable-next-line
+  Rt || Ct
+);
+function lt(e) {
+  return J.fromString(e, !0, 16);
+}
+const Tt = lt("c3a5c85c97cb3127"), Q = lt("b492b66fbe98f273"), W = lt("9ae16a3b2f90404f");
+function ft(e) {
+  return e.xor(e.shru(47));
+}
+function vt(e, t, n) {
+  const r = e.slice(t, t + n);
+  return J.fromBytes(Array.from(r), !0, !0);
+}
+function v(e, t) {
+  return vt(e, t, 8);
+}
+function wt(e, t) {
+  return vt(e, t, 4);
+}
+function N(e, t) {
+  return t === 0 ? e : e.shru(t).or(e.shl(64 - t));
+}
+function X(e, t, n = lt("9ddfea08eb382d69")) {
+  let r = e.xor(t).mul(n);
+  r = r.xor(r.shru(47));
+  let o = t.xor(r).mul(n);
+  return o = o.xor(o.shru(47)), o = o.mul(n), o;
+}
+function Bt(e, t, n, r, o, s) {
+  o = o.add(e), s = N(s.add(o).add(r), 21);
+  const i = o;
+  return o = o.add(t), o = o.add(n), s = s.add(N(o, 44)), [o.add(r), s.add(i)];
+}
+function st(e, t, n, r) {
+  return Bt(v(e, t), v(e, t + 8), v(e, t + 16), v(e, t + 24), n, r);
+}
+function kt(e, t = e.length) {
+  if (t >= 8) {
+    const n = W.add(t * 2), r = v(e, 0).add(W), o = v(e, t - 8), s = N(o, 37).mul(n).add(r), i = N(r, 25).add(o).mul(n);
+    return X(s, i, n);
+  }
+  if (t >= 4) {
+    const n = W.add(t * 2), r = wt(e, 0);
+    return X(r.shl(3).add(t), wt(e, t - 4), n);
+  }
+  if (t > 0) {
+    const n = e[0], r = e[t >> 1], o = e[t - 1], s = n + (r << 8), i = t + (o << 2);
+    return ft(W.mul(s).xor(Tt.mul(i))).mul(W);
+  }
+  return W;
+}
+function Ht(e, t = e.length) {
+  const n = W.add(t * 2), r = v(e, 0).mul(Q), o = v(e, 8), s = v(e, t - 8).mul(n), i = v(e, t - 16).mul(W);
+  return X(N(r.add(o), 43).add(N(s, 30)).add(i), r.add(N(o.add(W), 18)).add(s), n);
+}
+function Kt(e, t = e.length) {
+  const n = W.add(t * 2), r = v(e, 0).mul(W), o = v(e, 8), s = v(e, t - 8).mul(n), i = v(e, t - 16).mul(W), u = N(r.add(o), 43).add(N(s, 30)).add(i), a = X(u, r.add(N(o.add(W), 18)).add(s), n), h = v(e, 16).mul(n), c = v(e, 24), f = u.add(v(e, t - 32)).mul(n), p = a.add(v(e, t - 24)).mul(n);
+  return X(N(h.add(c), 43).add(N(f, 30)).add(p), h.add(N(c.add(r), 18)).add(f), n);
+}
+function Xt(e, t = e.length) {
+  const n = J.fromNumber(81, !0);
+  if (t <= 32)
+    return t <= 16 ? kt(e, t) : Ht(e, t);
+  if (t <= 64)
+    return Kt(e, t);
+  let r = n, o = n.mul(Q).add(113), s = ft(o.mul(W).add(113)).mul(W), i = [J.UZERO, J.UZERO], u = [J.UZERO, J.UZERO];
+  r = r.mul(W).add(v(e, 0));
+  let a = 0;
+  const h = (t - 1 >> 6) * 64, c = h + (t - 1 & 63) - 63;
+  do
+    r = N(r.add(o).add(i[0]).add(v(e, a + 8)), 37).mul(Q), o = N(o.add(i[1]).add(v(e, a + 48)), 42).mul(Q), r = r.xor(u[1]), o = o.add(i[0]).add(v(e, a + 40)), s = N(s.add(u[0]), 33).mul(Q), i = st(e, a, i[1].mul(Q), r.add(u[0])), u = st(e, a + 32, s.add(u[1]), o.add(v(e, a + 16))), [s, r] = [r, s], a += 64;
+  while (a !== h);
+  const f = Q.add(s.and(255).shl(1));
+  return a = c, u[0] = u[0].add(t - 1 & 63), i[0] = i[0].add(u[0]), u[0] = u[0].add(i[0]), r = N(r.add(o).add(i[0]).add(v(e, a + 8)), 37).mul(f), o = N(o.add(i[1]).add(v(e, a + 48)), 42).mul(f), r = r.xor(u[1].mul(9)), o = o.add(i[0].mul(9).add(v(e, a + 40))), s = N(s.add(u[0]), 33).mul(f), i = st(e, a, i[1].mul(f), r.add(u[0])), u = st(e, a + 32, s.add(u[1]), o.add(v(e, a + 16))), [s, r] = [r, s], X(X(i[0], u[0], f).add(ft(o).mul(Tt)).add(s), X(i[1], u[1], f).add(r), f);
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+var H;
+(function(e) {
+  e[e.FIRST_DIM_SIZE = 0] = "FIRST_DIM_SIZE", e[e.VALUE_ROWIDS = 1] = "VALUE_ROWIDS", e[e.ROW_LENGTHS = 2] = "ROW_LENGTHS", e[e.ROW_SPLITS = 3] = "ROW_SPLITS", e[e.ROW_LIMITS = 4] = "ROW_LIMITS", e[e.ROW_STARTS = 5] = "ROW_STARTS";
+})(H || (H = {}));
+function Qt(e, t, n) {
+  let r = new Array();
+  if (n == null && t == null)
+    return r;
+  if (t == null)
+    for (; r.length < e + n.length; )
+      r.push(-1);
+  else
+    r = t.slice();
+  if (n == null)
+    return r;
+  if (e + n.length !== r.length)
+    throw new Error(`rt input.shape and shape=${t} are incompatible: rt input.rank = ${e + n.length}, but shape.rank = ${r.length}`);
+  for (let o = 1; o < n.length; ++o) {
+    const s = n[o], i = r[r.length - n.length + o], u = r[i];
+    if (s >= 0)
+      if (u >= 0) {
+        if (u !== s)
+          throw new Error(`rt input.shape and shape=${t} are incompatible: rt input.shape[${o + e}] = ${s} but shape[${o + e}] = ${u}`);
+      } else
+        r[i] = s;
+  }
+  return r;
+}
+function Jt(e) {
+  const t = {
+    FIRST_DIM_SIZE: H.FIRST_DIM_SIZE,
+    VALUE_ROWIDS: H.VALUE_ROWIDS,
+    ROW_LENGTHS: H.ROW_LENGTHS,
+    ROW_SPLITS: H.ROW_SPLITS,
+    ROW_LIMITS: H.ROW_LIMITS,
+    ROW_STARTS: H.ROW_STARTS
+  }, n = [];
+  for (const r of e)
+    if (r in t)
+      n.push(t[r]);
+    else
+      break;
+  return n;
+}
+function Yt(e) {
+  return e.length === 0 ? 0 : e[0] === H.FIRST_DIM_SIZE ? e.length - 1 : e.length;
+}
+function te(e, t) {
+  if (e == null || t == null)
+    return;
+  const n = e.length, r = t.length;
+  if (n >= r)
+    throw new Error(`defaultValue.shape=${e} and ragged tensor flatValues.shape=${t}, are incompatible: defaultValue.rank = ${n} must be less than ragged tensor input flatValues.rank = ${r})`);
+  for (let o = 0; o < Math.min(n, r - 1); ++o) {
+    const s = e[o], i = t[o + 1];
+    if (s >= 0 && i >= 0 && s !== 1 && s !== i)
+      throw new Error(`defaultValue.shape=${e}, and ragged tensor input flatValues.shape=${t} are incompatible: defaultValue.shape[${o - e.length}] = ${s} but ragged tensor input.flatValues.shape[${o - e.length}] = ${i}`);
+  }
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function ee(e) {
+  return `Received SparseTensor with denseShape[0] = 0 but
+  indices.shape[0] = ${e}`;
+}
+function ne(e, t) {
+  return `indices(${e}, 0) is invalid: ${t} < 0`;
+}
+function re(e, t, n) {
+  return `indices(${e}, 0) is invalid: ${t} >= ${n}`;
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function oe(e, t) {
+  return `only one output dimension may be -1, not both ${e} and ${t}`;
+}
+function se(e, t) {
+  return `size ${e} must be non-negative, not ${t}`;
+}
+function ie() {
+  return "reshape cannot infer the missing input size for an empty tensor unless all specified input sizes are non-zero";
+}
+function le(e, t) {
+  const n = $(e), r = $(t);
+  return `Input to reshape is a SparseTensor with ${n}
+  dense values, but the requested shape requires a multiple of ${r}. inputShape=${e} outputShape= ${t}`;
+}
+function ue(e, t) {
+  const n = $(e), r = $(t);
+  return `Input to reshape is a tensor with ${n} dense values, but the requested shape has ${r}. inputShape=${e} outputShape=${t}`;
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function pt() {
+  return "segment ids must be >= 0";
+}
+function ae() {
+  return "segment ids are not increasing";
+}
+function he(e, t) {
+  return `Segment id ${e} out of range [0, ${t}), possibly because segmentIds input is not sorted.`;
+}
+function ce(e, t, n) {
+  return `Bad: indices[${e}] == ${t} out of range [0, ${n})`;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function fe(e) {
+  const t = new Float32Array(e.length);
+  for (let n = 0; n < e.length; ++n)
+    t[n] = Math.abs(e[n]);
+  return t;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function U(e) {
+  return (t, n, r, o, s) => {
+    const i = yt(t, n), u = i.length, a = Y(i), h = $(i), c = nt(s, h), f = t.length, p = n.length, I = Y(t), m = Y(n), b = dt(t, i), g = dt(n, i);
+    if (b.length + g.length === 0)
+      for (let d = 0; d < c.length; ++d)
+        c[d] = e(r[d % r.length], o[d % o.length]);
+    else
+      for (let d = 0; d < c.length; ++d) {
+        const E = gt(d, u, a), R = E.slice(-f);
+        b.forEach((z) => R[z] = 0);
+        const x = ht(R, f, I), D = E.slice(-p);
+        g.forEach((z) => D[z] = 0);
+        const V = ht(D, p, m);
+        c[d] = e(r[x], o[V]);
+      }
+    return [c, i];
+  };
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function ge(e, t, n, r) {
+  if (r === "int32") {
+    const o = Int32Array.from(e);
+    return [t, "int32", o];
+  }
+  if (r === "bool") {
+    const o = Lt([0], n), [s, i] = U((u, a) => u !== a ? 1 : 0)(t, [], e, o, "bool");
+    return [i, "bool", s];
+  }
+  throw new Error(`Error in Cast: failed to cast ${n} to ${r}`);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const de = U((e, t) => e + t);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function me(e, t, n, r, o) {
+  const s = $(r), i = rt(o, n);
+  for (let u = 0; u < e.length; u++) {
+    const a = e[u];
+    if (a < 0)
+      throw new Error("Input x must be non-negative!");
+    a >= o || (s > 0 ? i[a] += t[u] : i[a] += 1);
+  }
+  return i;
+}
+function we(e, t, n, r = !1) {
+  const o = e.shape[0], s = e.shape[1], i = k([o, n], t.dtype);
+  for (let u = 0; u < o; u++)
+    for (let a = 0; a < s; a++) {
+      const h = e.get(u, a);
+      if (h < 0)
+        throw new Error("Input x must be non-negative!");
+      h >= n || (r ? i.set(1, u, h) : t.size > 0 ? i.set(i.get(u, h) + t.get(u, a), u, h) : i.set(i.get(u, h) + 1, u, h));
+    }
+  return i;
+}
+/**
+ * @license
+ * Copyright 2023 Google LLC.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const pe = U((e, t) => e & t);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function K(e) {
+  return (t, n, r) => {
+    const o = q(n, t.length);
+    for (let s = 0; s < t.length; ++s)
+      o[s] = e(t[s], r);
+    return o;
+  };
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Ie = K((e) => Math.ceil(e));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Ee(e, t, n, r) {
+  const o = q(n, $(t));
+  if (r && n !== "string") {
+    let s = 0;
+    e.forEach((i) => {
+      const u = $(i.shape);
+      o.set(i.vals, s), s += u;
+    });
+  } else {
+    let s = 0;
+    e.forEach((i) => {
+      const u = n === "string" ? bt(i.vals) : i.vals;
+      let a = 0;
+      for (let h = 0; h < i.shape[0]; ++h) {
+        const c = h * t[1] + s;
+        for (let f = 0; f < i.shape[1]; ++f)
+          o[c + f] = u[a++];
+      }
+      s += i.shape[1];
+    });
+  }
+  return o;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Se = U((e, t) => e === t ? 1 : 0);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Fe = K((e) => Math.exp(e));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const be = K((e) => Math.expm1(e));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const xe = K((e) => Math.floor(e));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Re = U((e, t) => Math.floor(e / t));
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Te(e, t, n, r, o, s, i, u, a) {
+  const h = k([r, s], n);
+  for (let c = 0; c < r; c++) {
+    const f = [];
+    let p = 0;
+    for (let I = 0; I < o; I++) {
+      const m = e[c * o + I];
+      p += m * i[I], f.push(m);
+    }
+    if (p < 0 || p >= a / s)
+      throw new Error(`Invalid indices: ${f} does not index into ${u}`);
+    for (let I = 0; I < s; I++)
+      h.values[c * s + I] = t.get(...t.indexToLoc(p * s + I));
+  }
+  return h;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function ve(e, t, n) {
+  const r = k(n, e.dtype);
+  for (let o = 0; o < r.size; ++o) {
+    const i = r.indexToLoc(o).slice(), u = i[0], a = i[2], h = t.locToIndex([u, a]);
+    i[2] = t.values[h];
+    const c = e.locToIndex(i);
+    0 <= c && c < e.values.length && (r.values[o] = e.values[c]);
+  }
+  return r;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Oe = U((e, t) => e > t ? 1 : 0);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const _e = U((e, t) => e >= t ? 1 : 0);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const ye = U((e, t) => e < t ? 1 : 0);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Le = U((e, t) => e <= t ? 1 : 0);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Me(e, t, n) {
+  const r = (t - e) / (n - 1), o = rt(n, "float32");
+  o[0] = e;
+  for (let s = 1; s < o.length; s++)
+    o[s] = o[s - 1] + r;
+  return o;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Ne = K((e) => Math.log(e));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function $e(e, t, n, r) {
+  const o = nt(r, $(n));
+  for (let s = 0; s < o.length; ++s) {
+    const i = s * t;
+    let u = e[i];
+    for (let a = 0; a < t; ++a) {
+      const h = e[i + a];
+      (Number.isNaN(h) || h > u) && (u = h);
+    }
+    o[s] = u;
+  }
+  return o;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Ae = U((e, t) => Math.max(e, t));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const De = U((e, t) => Math.min(e, t));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Ot = U((e, t) => e * t);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Pe(e, t, n) {
+  const r = Mt(-1, n);
+  return Ot([], t, r, e, n);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const We = U((e, t) => e !== t ? 1 : 0);
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function qe(e, t, n, r, o) {
+  const s = t.length, i = $(t), u = Y(t), a = Y(o), h = nt(n, $(o));
+  for (let c = 0; c < i; ++c) {
+    const f = gt(c, s, u), p = new Array(f.length);
+    for (let m = 0; m < p.length; m++)
+      p[m] = f[r[m]];
+    const I = ht(p, s, a);
+    h[I] = e[c];
+  }
+  return h;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Ve(e, t, n, r) {
+  const [o, s] = Wt(e, r), i = Nt(t, "int32"), u = rt($(o), i), a = $(s);
+  for (let h = 0; h < u.length; ++h) {
+    const c = h * a;
+    let f = 1;
+    for (let p = 0; p < a; ++p)
+      f *= n[c + p];
+    u[h] = f;
+  }
+  return { outVals: u, outShape: o, outDtype: i };
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Ue(e, t, n) {
+  e.forEach((r, o) => {
+    if (r < 0 || r >= n) {
+      const s = gt(o, t.length, Y(t)).join(",");
+      throw new Error(`indices[${s}] = ${r} is not in [0, ${n})`);
+    }
+  });
+}
+function ze(e, t) {
+  for (let n = 0; n < e.length; ++n) {
+    const r = e[n], o = n === e.length - 1 ? t : e[n + 1].length;
+    if (r.length === 0)
+      throw new Error("Ragged splits may not be empty");
+    if (r[0] < 0)
+      throw new Error("Ragged splits must be non-negative");
+    if (r[r.length - 1] > o)
+      throw new Error("Ragged splits must not point past values");
+    for (let s = 1; s < r.length; ++s)
+      if (r[s - 1] > r[s])
+        throw new Error("Ragged splits must be sorted in ascending order");
+  }
+}
+function Ge(e, t, n, r) {
+  const o = [];
+  let s = 0;
+  const i = t.length - 1 + n.length, u = new Array(i).fill(null).map(() => [0]);
+  ze(n, r);
+  let a = 1;
+  for (let h = 0; h < t.length - 1; ++h) {
+    a *= t[h];
+    const c = t[h + 1];
+    for (let f = 1; f < a + 1; ++f)
+      u[h].push(f * c);
+  }
+  for (let h = 0; h < e.length; ++h) {
+    let c = e[h], f = e[h] + 1;
+    for (let p = 0; p < n.length; ++p) {
+      const I = n[p], m = p + t.length - 1;
+      if (m >= 0) {
+        const b = u[m], g = b[b.length - 1] - I[c];
+        for (let d = c; d < f; ++d)
+          u[m].push(I[d + 1] + g);
+      }
+      c = I[c], f = I[f];
+    }
+    f !== c && (o.push([c, f]), s += f - c);
+  }
+  return { outSplits: u, valueSlices: o, numValues: s };
+}
+function je(e) {
+  const t = [];
+  for (let n = 0; n < e.length; ++n) {
+    const r = e[n].length, o = q("int32", r);
+    t.push(o), e[n].forEach((s, i) => o[i] = s);
+  }
+  return t;
+}
+function It(e, t) {
+  const n = e.slice(0, t);
+  for (; n.length < t; )
+    n.push(1);
+  for (let r = t; r < e.length; r++)
+    n[t - 1] *= e[r];
+  return n;
+}
+function Ze(e, t, n, r, o, s) {
+  const i = It(t, 2)[1], u = It(s, 2)[1];
+  let a = 0;
+  for (const h of n)
+    for (let c = h[0]; c < h[1]; ++c) {
+      for (let f = 0; f < r; ++f)
+        o[a * u + f] = e[c * i + f];
+      ++a;
+    }
+}
+function Ce(e, t, n, r, o) {
+  const s = t.slice();
+  s[0] = o;
+  const i = q(n, $(s)), u = e.length, a = u === 0 ? 0 : u / t[0];
+  return Ze(e, t, r, a, i, s), [i, s];
+}
+function Be(e, t, n, r, o, s, i, u) {
+  if (e.length === 0)
+    throw new Error("paramsNestedSplits must be non empty");
+  if (t[0].length === 0)
+    throw new Error("Split tensors must not be scalars");
+  const a = t[0][0] - 1;
+  if (Ue(s, i, a), r.length === 0)
+    throw new Error("params.rank must be nonzero");
+  const h = r[0], { outSplits: c, valueSlices: f, numValues: p } = Ge(s, i, e, h), I = je(c), m = Ce(n, r, o, f, p);
+  return [I, m[0], m[1]];
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Et = 2147483647;
+function ke(e, t, n, r, o, s, i) {
+  if (t.length > 1)
+    throw new Error("starts must be a scalar or vector");
+  if (o.length > 1)
+    throw new Error("limits must be a scalar or vector");
+  if (i.length > 1)
+    throw new Error("deltas must be a scalar or vector");
+  const u = t.length === 0, a = o.length === 0, h = i.length === 0, c = [];
+  u || c.push(t[0]), a || c.push(o[0]), h || c.push(i[0]);
+  for (let g = 1; g < c.length; ++g)
+    if (c[g] !== c[g - 1])
+      throw new Error("starts, limits, and deltas must have the same shape");
+  const f = c.length === 0 ? 1 : c[0], p = q("int32", f + 1);
+  p[0] = 0;
+  for (let g = 0; g < f; ++g) {
+    const d = u ? e[0] : e[g], E = a ? r[0] : r[g], R = h ? s[0] : s[g];
+    if (R === 0)
+      throw new Error("Requires delta != 0");
+    let x;
+    if (R > 0 && E < d || R < 0 && E > d)
+      x = 0;
+    else if (x = Math.ceil(Math.abs((E - d) / R)), x > Et)
+      throw new Error(`Requires ((limit - start) / delta) <= ${Et}`);
+    p[g + 1] = p[g] + x;
+  }
+  const I = p[f], m = q(n, I);
+  let b = 0;
+  for (let g = 0; g < f; ++g) {
+    const d = p[g + 1] - p[g];
+    let E = u ? e[0] : e[g];
+    const R = h ? s[0] : s[g];
+    for (let x = 0; x < d; ++x)
+      m[b++] = E, E += R;
+  }
+  return [p, m];
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+var B = H;
+class it {
+  constructor(t, n, r, o, s, i, u, a, h, c) {
+    this.shape = t, this.shapeShape = n, this.values = r, this.valuesShape = o, this.valuesDType = s, this.defaultValue = i, this.defaultValueShape = u, this.rowPartitionValues = a, this.rowPartitionValuesShapes = h, this.rowPartitionTypes = Jt(c), this.raggedRank = Yt(this.rowPartitionTypes);
+  }
+  getRowPartitionTypeByDimension(t) {
+    return this.rowPartitionTypes[0] === B.FIRST_DIM_SIZE ? this.rowPartitionTypes[t + 1] : this.rowPartitionTypes[t];
+  }
+  // Returns the relationship between dimension and dimension + 1.
+  getRowPartitionTensor(t) {
+    return this.rowPartitionTypes[0] === B.FIRST_DIM_SIZE ? this.rowPartitionValues[t + 1] : this.rowPartitionValues[t];
+  }
+  getMaxWidth(t) {
+    const n = this.getRowPartitionTensor(t - 1);
+    switch (this.getRowPartitionTypeByDimension(t - 1)) {
+      case B.VALUE_ROWIDS:
+        return it.getMaxWidthValueRowID(n);
+      case B.ROW_SPLITS:
+        return it.getMaxWidthRowSplit(n);
+      default:
+        throw new Error(`Cannot handle partition type ${B[this.getRowPartitionTypeByDimension(t - 1)]}`);
+    }
+  }
+  static getMaxWidthRowSplit(t) {
+    const n = t.length;
+    if (n === 0 || n === 1)
+      return 0;
+    let r = 0;
+    for (let o = 0; o < n - 1; ++o) {
+      const s = t[o + 1] - t[o];
+      s > r && (r = s);
+    }
+    return r;
+  }
+  static getMaxWidthValueRowID(t) {
+    const n = t.length;
+    if (n === 0)
+      return 0;
+    let r = 0, o = t[0], s = 0;
+    for (let i = 1; i < n; ++i) {
+      const u = t[i];
+      u !== o && (o = u, s = Math.max(i - r, s), r = i);
+    }
+    return Math.max(n - r, s);
+  }
+  tensorShapeFromTensor(t, n, r = !0) {
+    if (n.length === 0) {
+      if (t[0] === -1)
+        return [];
+      throw new Error("The only valid scalar shape tensor is the fully unknown shape specified as -1.");
+    }
+    return Ft(t, r);
+  }
+  calculateOutputSize(t) {
+    const n = this.valuesShape, r = this.defaultValueShape;
+    te(r, n);
+    const o = this.tensorShapeFromTensor(this.shape, this.shapeShape), i = Qt(this.raggedRank, o, n);
+    i[0] < 0 && (i[0] = t);
+    for (let u = 1; u <= this.raggedRank; ++u)
+      i[u] < 0 && (i[u] = this.getMaxWidth(u));
+    return i;
+  }
+  /**
+   * The outputIndex represents the index in the output tensor
+   * where the first element of a particular dimension would be written.
+   * If it is -1, it indicates that the index is out of scope.
+   * Example, given firstDimension = 10, firstDimensionOutput = 6,
+   * and outputIndexMultiplier = 100:
+   * result = [0 100 200 300 400 500 -1 -1 -1 -1]
+   * If firstDimensionOutput = 11 instead, then:
+   * result = [0 100 200 300 400 500 600 700 800 900]
+   */
+  calculateFirstParentOutputIndex(t, n, r) {
+    const o = Math.min(t, r), s = [];
+    let i = 0;
+    for (let u = 0; u < o; ++u, i += n)
+      s.push(i);
+    for (let u = o; u < t; ++u)
+      s.push(-1);
+    return $t(s.length === t, () => "Final length of result must be equal to firstDimension."), s;
+  }
+  calculateOutputIndexRowSplit(t, n, r, o) {
+    const s = t.length, i = [];
+    for (let u = 0; u < s - 1; ++u) {
+      const a = t[u + 1] - t[u];
+      let h = Math.min(o, a), c = n[u];
+      c === -1 && (h = 0);
+      for (let f = 0; f < h; ++f)
+        i.push(c), c += r;
+      for (let f = 0; f < a - h; ++f)
+        i.push(-1);
+    }
+    if (s > 0 && i.length !== t[s - 1])
+      throw new Error("Invalid row split size.");
+    return i;
+  }
+  // Calculate the output index of the first element of a list.
+  // The parentOutputIndex is the same computation for the previous list.
+  // -1 indicates an element or list that is out of range.
+  // The outputIndexMultiplier is the number of output indices one moves
+  // forward for each column.
+  // E.g., given:
+  // valueRowIds:[0 1 2 2 2 3 5 5 6]
+  // parentOutputIndex:[1000 1100 2000 2100 -1 3000 4000]
+  // outputIndexMultiplier: 10
+  // outputSize: 2
+  // You get:
+  // result = [1000 1100 2000 2010 -1 2100 -1 -1 3000]
+  // result[0] = parentOutputIndex[valueRowIds[0]]
+  // result[1] = parentOutputIndex[valueRowIds[1]]
+  // result[2] = parentOutputIndex[valueRowIds[2]]
+  // result[3] = parentOutputIndex[valueRowIds[2] + 10]
+  // result[4] = -1 because it is the third element the size is 2.
+  // result[5] = parentOutputIndex[valueRowIds[3]]
+  // result[6] = -1 because parentOutputIndex[valueRowIds[6]] == -1
+  // result[7] = -1 because parentOutputIndex[valueRowIds[6]] == -1
+  // result[8] = parentOutputIndex[valueRowIds[7]]
+  calculateOutputIndexValueRowID(t, n, r, o) {
+    const s = t.length, i = [];
+    if (s === 0)
+      return [];
+    let u = 0, a = t[0];
+    if (a >= n.length)
+      throw new Error(`Got currentValueRowId=${a}, which is not less than ${n.length}`);
+    let h = n[a];
+    i.push(h);
+    for (let c = 1; c < s; ++c) {
+      const f = t[c];
+      if (f === a)
+        h >= 0 && (++u, u < o ? h += r : h = -1);
+      else {
+        if (u = 0, a = f, f >= n.length)
+          throw new Error(`Got nextValueRowId=${f} which is not less than ${n.length}`);
+        h = n[f];
+      }
+      i.push(h);
+    }
+    if (i.length !== t.length)
+      throw new Error("Invalid row ids.");
+    return i;
+  }
+  calculateOutputIndex(t, n, r, o) {
+    const s = this.getRowPartitionTensor(t), i = this.getRowPartitionTypeByDimension(t);
+    switch (i) {
+      case B.VALUE_ROWIDS:
+        return this.calculateOutputIndexValueRowID(s, n, r, o);
+      case B.ROW_SPLITS:
+        if (s.length - 1 > n.length)
+          throw new Error(`Row partition size is greater than output size: ${s.length - 1} > ${n.length}`);
+        return this.calculateOutputIndexRowSplit(s, n, r, o);
+      default:
+        throw new Error(`Unsupported partition type: ${B[i]}`);
+    }
+  }
+  getFirstDimensionSize() {
+    const t = this.rowPartitionValues[0];
+    if (this.rowPartitionTypes.length === 0)
+      throw new Error("No row_partition_types given.");
+    const n = this.rowPartitionTypes[0];
+    switch (n) {
+      case B.FIRST_DIM_SIZE:
+        return t[0];
+      case B.VALUE_ROWIDS:
+        throw new Error("Cannot handle VALUE_ROWIDS in first dimension.");
+      case B.ROW_SPLITS:
+        return this.rowPartitionValuesShapes[0][0] - 1;
+      default:
+        throw new Error(`Cannot handle type ${B[n]}`);
+    }
+  }
+  compute() {
+    if (this.rowPartitionValues[0].length <= 0)
+      throw new Error("Invalid first partition input. Tensor requires at least one element.");
+    const n = this.getFirstDimensionSize(), r = this.calculateOutputSize(n), o = new Array(this.raggedRank + 1);
+    o[o.length - 1] = 1;
+    for (let a = o.length - 2; a >= 0; --a)
+      o[a] = o[a + 1] * r[a + 1];
+    const s = Ft(r, !1), i = q(this.valuesDType, $(s));
+    if (o[0] * r[0] > 0) {
+      let a = this.calculateFirstParentOutputIndex(n, o[0], r[0]);
+      for (let h = 1; h <= this.raggedRank; ++h)
+        a = this.calculateOutputIndex(h - 1, a, o[h], r[h]);
+      this.setOutput(this.raggedRank, a, i, s);
+    }
+    return [s, i];
+  }
+  setOutput(t, n, r, o) {
+    if (r.length === 0)
+      return;
+    const s = this.values, i = r;
+    let u = o.slice();
+    u = u.slice(t + 1);
+    const a = $(u), h = n.length;
+    let c = this.defaultValue;
+    if (c.length !== a && c.length !== 1) {
+      const m = this.defaultValueShape;
+      At(() => {
+        const b = Vt(c, m);
+        c = qt(b, u).dataSync();
+      });
+    }
+    let f = 0, p = 0, I = 0;
+    for (let m = 0; m <= h; ++m) {
+      let b = m < h ? n[m] : -1;
+      if (b === I) {
+        ++I;
+        continue;
+      }
+      if (p < I) {
+        const g = s.subarray(f * a), d = i.subarray(p * a), E = (I - p) * a;
+        St(d, g, E);
+      }
+      if (m >= h) {
+        const g = r.length;
+        b = Math.floor(g / a);
+      }
+      if (b > I)
+        if (this.defaultValue.length === 1)
+          i.subarray(I * a, b * a).fill(this.defaultValue[0]), I = b;
+        else
+          for (; b > I; ) {
+            const g = i.slice(I * a);
+            St(g, c, a), ++I;
+          }
+      b < 0 ? (f = m + 1, p = I) : (f = m, p = I, I = p + 1);
+    }
+  }
+}
+function St(e, t, n) {
+  for (let r = 0; r < n; r++)
+    e[r] = t[r];
+}
+function Ft(e, t) {
+  const n = [];
+  for (let r of e) {
+    if (r < 0) {
+      if (!t)
+        throw new Error(`Dimension ${r} must be >= 0`);
+      if (r < -1)
+        throw new Error(`Dimension ${r} must be >= -1`);
+      r = -1;
+    }
+    n.push(r);
+  }
+  return n;
+}
+function He(e, t, n, r, o, s, i, u, a, h) {
+  return new it(e, t, n, r, o, s, i, u, a, h).compute();
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Ke(e, t, n, r) {
+  const o = e === t, s = e < t && n < 0, i = t < e && n > 1;
+  if (o || s || i)
+    return rt(0, r);
+  const u = Math.abs(Math.ceil((t - e) / n)), a = rt(u, r);
+  t < e && n === 1 && (n = -1), a[0] = e;
+  for (let h = 1; h < a.length; h++)
+    a[h] = a[h - 1] + n;
+  return a;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Xe = K((e) => 1 / Math.sqrt(e));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Qe(e, t, n, r, o, s, i, u, a, h) {
+  const c = [r / o, o], f = e.values, p = t.values;
+  if (r === 0)
+    return k(n, t.dtype);
+  const I = a instanceof ct ? a : k(c, t.dtype);
+  typeof a == "string" || typeof a == "number" ? I.values.fill(a) : typeof a == "boolean" && I.values.fill(+a);
+  for (let m = 0; m < s; m++) {
+    const b = [];
+    let g = 0;
+    for (let d = 0; d < i; d++) {
+      const E = f[m * i + d];
+      b.push(E), g += E * u[d];
+    }
+    if (g < 0 || g >= r / o)
+      throw new Error(`Invalid indices: ${b} does not index into ${n}`);
+    for (let d = 0; d < o; d++)
+      h ? I.values[g * o + d] += p[m * o + d] : I.values[g * o + d] = t.rank === 0 ? p[0] : p[m * o + d];
+  }
+  return I;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Je = K((e) => 1 / (1 + Math.exp(-e)));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Ye(e, t, n, r, o) {
+  const s = Ut(r, t, n), i = $(n), u = Y(r);
+  if (s) {
+    const f = zt(t, u);
+    return o === "string" ? e.slice(f, f + i) : e.subarray(f, f + i);
+  }
+  const a = o === "string" ? bt(e) : e, h = k(r, o, a), c = k(n, o);
+  for (let f = 0; f < c.size; ++f) {
+    const p = c.indexToLoc(f), I = p.map((m, b) => m + t[b]);
+    c.set(h.get(...I), ...p);
+  }
+  return o === "string" ? Pt(c.values) : c.values;
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function tn(e, t, n, r, o, s, i) {
+  const u = t[0], a = s[0], h = new Array(a), c = new Array(u), f = t[1];
+  if (a === 0) {
+    if (u !== 0)
+      throw new Error(ee(u));
+    const g = q(n, 0), d = q(o, 0);
+    return [
+      g,
+      [0, f],
+      d,
+      h,
+      c
+    ];
+  }
+  let p = !0, I = 0;
+  const m = new Array(a).fill(0);
+  for (let g = 0; g < u; ++g) {
+    const d = e[g * f];
+    if (d < 0)
+      throw new Error(ne(g, d));
+    if (d >= a)
+      throw new Error(re(g, d, a));
+    ++m[d], p = p && d >= I, I = d;
+  }
+  let b = !0;
+  for (let g = 0; g < a; ++g) {
+    const d = m[g] === 0;
+    h[g] = d, b = b && !d, m[g] = Math.max(m[g], 1), g > 0 && (m[g] += m[g - 1]);
+  }
+  if (b && p) {
+    const g = e, d = r;
+    for (let E = 0; E < u; ++E)
+      c[E] = E;
+    return [
+      g,
+      [u, f],
+      d,
+      h,
+      c
+    ];
+  } else {
+    const g = m[a - 1], d = q(n, g * f), E = q(o, g), R = new Array(a).fill(0);
+    for (let x = 0; x < u; ++x) {
+      const D = e[x * f], V = R[D], z = (D === 0 ? 0 : m[D - 1]) + V;
+      R[D]++;
+      for (let L = 0; L < f; ++L)
+        d[z * f + L] = e[x * f + L];
+      E[z] = r[x], c[x] = z;
+    }
+    for (let x = 0; x < a; ++x)
+      if (R[x] === 0) {
+        const V = x === 0 ? 0 : m[x - 1];
+        d[V * f + 0] = x;
+        for (let z = 1; z < f; ++z)
+          d[V * f + z] = 0;
+        E[V] = i;
+      }
+    return [
+      d,
+      [g, f],
+      E,
+      h,
+      c
+    ];
+  }
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function en(e, t, n, r, o) {
+  const s = $(r), i = t[0], u = o.length, a = [];
+  let h = 1, c = -1;
+  for (let g = 0; g < u; ++g) {
+    const d = o[g];
+    if (d === -1) {
+      if (c !== -1)
+        throw new Error(oe(c, g));
+      c = g, a.push(1);
+    } else {
+      if (d < 0)
+        throw new Error(se(g, d));
+      h *= d, a.push(d);
+    }
+  }
+  if (c !== -1) {
+    if (h <= 0)
+      throw new Error(ie());
+    const g = Math.trunc(s / h);
+    if (h * g !== s)
+      throw new Error(le(r, a));
+    a[c] = g;
+  }
+  if ($(a) !== s)
+    throw new Error(ue(r, a));
+  const p = r.length, I = [];
+  if (p > 0) {
+    I[p - 1] = 1;
+    for (let g = p - 2; g >= 0; --g)
+      I[g] = I[g + 1] * r[g + 1];
+  }
+  const m = [];
+  if (u > 0) {
+    m[u - 1] = 1;
+    for (let g = u - 2; g >= 0; --g)
+      m[g] = m[g + 1] * a[g + 1];
+  }
+  const b = q(n, i * u);
+  for (let g = 0; g < i; ++g) {
+    let d = 0;
+    for (let E = 0; E < p; ++E)
+      d += e[g * p + E] * I[E];
+    for (let E = 0; E < u; ++E)
+      b[g * u + E] = Math.trunc(d / m[E]), d %= m[E];
+  }
+  return [b, [i, u], a];
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function nn(e, t, n, r, o, s = !1, i = 0) {
+  const u = r.length, a = [t[0], e.length / t[0]], h = a[1], f = u > 0 ? o[u - 1] + 1 : 0;
+  if (f < 0)
+    throw new Error(pt());
+  const p = t.slice();
+  p[0] = f;
+  const I = p.reduce((R, x) => R * x, 1), m = q(n, I);
+  if (u === 0)
+    return f > 0 && m.fill(i), [m, p];
+  if (f <= 0)
+    throw new Error(pt());
+  let b = 0, g = 1, d = 0, E = o[b];
+  for (; ; ) {
+    let R = 0;
+    if (g < u) {
+      if (R = o[g], E === R) {
+        ++g;
+        continue;
+      }
+      if (E >= R)
+        throw new Error(ae());
+    }
+    if (E < 0 || E >= f)
+      throw new Error(he(E, f));
+    E > d && m.fill(i, d * h, E * h);
+    for (let x = b; x < g; ++x) {
+      const D = r[x];
+      if (D < 0 || D >= a[0])
+        throw new Error(ce(x, r[x], a[0]));
+      for (let V = 0; V < h; V++)
+        m[E * h + V] += e[D * h + V];
+    }
+    if (s)
+      for (let x = 0; x < h; x++)
+        m[E * h + x] /= g - b;
+    if (b = g, ++g, d = E + 1, E = R, g > u)
+      break;
+  }
+  return d < f && m.fill(i, d * h, f * h), [m, p];
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const rn = K((e) => Math.sqrt(e));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const on = U((e, t) => {
+  const n = e - t;
+  return n * n;
+});
+/**
+ * @license
+ * Copyright 2023 Google LLC.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const sn = K((e, t) => {
+  const { pattern: n, replaceGlobal: r, rewrite: o } = t;
+  return e.replace(new RegExp(n, r ? "g" : ""), o);
+});
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function ln(e, t, n, r) {
+  const o = k(e, t.dtype);
+  for (let s = 0; s < o.size; s++) {
+    const i = o.indexToLoc(s), u = new Array(i.length);
+    for (let a = 0; a < u.length; a++)
+      u[a] = i[a] * n[a] + r[a];
+    o.set(t.get(...u), ...i);
+  }
+  return o;
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+class un {
+  constructor(t, n, r, o, s, i) {
+    this.separator = ut(t), this.nGramWidths = n, this.leftPad = ut(r), this.rightPad = ut(o), this.padWidth = s, this.preserveShort = i;
+  }
+  getPadWidth(t) {
+    return Math.min(this.padWidth < 0 ? t - 1 : this.padWidth, t - 1);
+  }
+  getNumNGrams(t, n) {
+    const r = this.getPadWidth(n);
+    return Math.max(0, t + 2 * r - n + 1);
+  }
+  createNGrams(t, n, r, o, s, i) {
+    for (let u = 0; u < s; ++u) {
+      const a = this.getPadWidth(i), h = Math.max(0, a - u), c = Math.max(0, a - (s - (u + 1))), f = i - (h + c), p = n + (h > 0 ? 0 : u - a);
+      let I = 0;
+      I += h * this.leftPad.length;
+      for (let E = 0; E < f; ++E)
+        I += t[p + E].length;
+      I += c * this.rightPad.length;
+      const m = h + c + f - 1;
+      I += m * this.separator.length, r[o + u] = new Uint8Array(I);
+      const b = r[o + u];
+      let g = 0;
+      const d = (E) => E.forEach((R) => b[g++] = R);
+      for (let E = 0; E < h; ++E)
+        d(this.leftPad), d(this.separator);
+      for (let E = 0; E < f - 1; ++E)
+        d(t[p + E]), d(this.separator);
+      if (f > 0) {
+        d(t[p + f - 1]);
+        for (let E = 0; E < c; ++E)
+          d(this.separator), d(this.rightPad);
+      } else {
+        for (let E = 0; E < c - 1; ++E)
+          d(this.rightPad), d(this.separator);
+        d(this.rightPad);
+      }
+    }
+  }
+  // Data and splits together form the definition of the ragged tensor,
+  // where data is 1 dimensional and contains the values of the tensor
+  // and splits denotes the indices at which each row starts.
+  compute(t, n) {
+    const r = t.length, o = n.length;
+    if (o > 0) {
+      let a = n[0];
+      if (a !== 0)
+        throw new Error(`First split value must be 0, got ${a}`);
+      for (let h = 1; h < o; ++h) {
+        let c = n[h] >= a;
+        if (c = c && n[h] <= r, !c)
+          throw new Error(`Invalid split value ${n[h]}, must be in [${a}, ${r}]`);
+        a = n[h];
+      }
+      if (a !== r)
+        throw new Error(`Last split value must be data size. Expected ${r}, got ${a}`);
+    }
+    const s = o - 1, i = q("int32", o);
+    if (r === 0 || o === 0) {
+      const a = new Array(r);
+      for (let h = 0; h <= s; ++h)
+        i[h] = 0;
+      return [a, i];
+    }
+    i[0] = 0;
+    for (let a = 1; a <= s; ++a) {
+      const h = n[a] - n[a - 1];
+      let c = 0;
+      this.nGramWidths.forEach((f) => {
+        c += this.getNumNGrams(h, f);
+      }), this.preserveShort && h > 0 && c === 0 && (c = 1), i[a] = i[a - 1] + c;
+    }
+    const u = new Array(i[s]);
+    for (let a = 0; a < s; ++a) {
+      const h = n[a];
+      let c = i[a];
+      if (this.nGramWidths.forEach((f) => {
+        const p = n[a + 1] - n[a], I = this.getNumNGrams(p, f);
+        this.createNGrams(t, h, u, c, I, f), c += I;
+      }), this.preserveShort && c === i[a]) {
+        const f = n[a + 1] - n[a];
+        if (f === 0)
+          continue;
+        const p = f + 2 * this.padWidth;
+        this.createNGrams(t, h, u, c, 1, p);
+      }
+    }
+    return [u, i];
+  }
+}
+function an(e, t, n, r, o, s, i, u) {
+  return new un(n, r, o, s, i, u).compute(e, t);
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function hn(e, t, n, r) {
+  if (!e.length)
+    return;
+  if (t.length === 0) {
+    for (let s = 0; s < e.length; ++s)
+      r.push(e.subarray(s, s + 1));
+    return;
+  }
+  if (t.length === 1) {
+    const s = t[0];
+    let i = e.indexOf(s);
+    for (; i !== -1; ) {
+      const u = e.subarray(0, i);
+      (!n || u.length !== 0) && r.push(u), e = e.subarray(i + 1), i = e.indexOf(s);
+    }
+    (!n || e.length !== 0) && r.push(e);
+    return;
+  }
+  let o = 0;
+  for (let s = 0; s < e.length + 1; s++)
+    if (s === e.length || t.indexOf(e[s]) !== -1) {
+      const i = e.subarray(o, s);
+      (!n || i.length !== 0) && r.push(i), o = s + 1;
+    }
+}
+function cn(e, t, n) {
+  const r = e.length, o = [];
+  let s = 0, i = 0;
+  const u = new Array(r);
+  for (let p = 0; p < r; ++p) {
+    const I = o.length;
+    hn(e[p], t, n, o);
+    const m = o.length - I;
+    u[p] = m, s += m, i = Math.max(i, m);
+  }
+  const a = q("int32", s * 2), h = new Array(s), c = [r, i];
+  let f = 0;
+  for (let p = 0; p < r; ++p)
+    for (let I = 0; I < u[p]; ++I)
+      a[f * 2] = p, a[f * 2 + 1] = I, h[f] = o[f], ++f;
+  return [a, h, c];
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function fn(e, t) {
+  const n = q("int32", e.length);
+  for (let r = 0; r < e.length; ++r)
+    n[r] = Xt(e[r]).modulo(t).getLowBitsUnsigned();
+  return n;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const gn = U((e, t) => e - t);
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function dn(e, t) {
+  const n = new Array(e.rank);
+  for (let o = 0; o < n.length; o++)
+    n[o] = e.shape[o] * t[o];
+  const r = k(n, e.dtype);
+  for (let o = 0; o < r.values.length; ++o) {
+    const s = r.indexToLoc(o), i = new Array(e.rank);
+    for (let a = 0; a < i.length; a++)
+      i[a] = s[a] % e.shape[a];
+    const u = e.locToIndex(i);
+    r.values[o] = e.values[u];
+  }
+  return r;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const et = (e, t) => {
+  const n = t.value - e.value;
+  return n === 0 ? e.index - t.index : n;
+};
+function _t(e, t, n = 0, r = e.length - 1) {
+  for (; r > n; ) {
+    if (r - n > 600) {
+      const u = r - n + 1, a = t - n + 1, h = Math.log(u), c = 0.5 * Math.exp(2 * h / 3), f = 0.5 * Math.sqrt(h * c * (u - c) / u) * Math.sign(a - u / 2), p = Math.max(n, Math.floor(t - a * c / u + f)), I = Math.min(r, Math.floor(t + (u - a) * c / u + f));
+      _t(e, t, p, I);
+    }
+    const o = e[t];
+    let s = n, i = r;
+    for (tt(e, n, t), et(e[r], o) > 0 && tt(e, n, r); s < i; ) {
+      for (tt(e, s, i), s++, i--; et(e[s], o) < 0; )
+        s = s + 1;
+      for (; et(e[i], o) > 0; )
+        i = i - 1;
+    }
+    et(e[n], o) === 0 ? tt(e, n, i) : (i = i + 1, tt(e, i, r)), i <= t && (n = i + 1), t <= i && (r = i - 1);
+  }
+}
+function mn(e, t, n, r, o) {
+  const s = t[t.length - 1], [i, u] = [e.length / s, s], a = nt(n, i * r), h = nt("int32", i * r);
+  for (let f = 0; f < i; f++) {
+    const p = f * u, I = e.subarray(p, p + u);
+    let m = new Array(I.length);
+    I.forEach((E, R) => m[R] = { value: E, index: R }), r < m.length && (_t(m, r), m = m.slice(0, r)), o && m.sort(et);
+    const b = f * r, g = a.subarray(b, b + r), d = h.subarray(b, b + r);
+    for (let E = 0; E < r; E++)
+      g[E] = m[E].value, d[E] = m[E].index;
+  }
+  const c = t.slice();
+  return c[c.length - 1] = r, [
+    k(c, n, a),
+    k(c, "int32", h)
+  ];
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function wn(e, t, n, r) {
+  const o = Dt(t, n)[0], s = [1, n[0], 1];
+  for (let m = 0; m < o; m++)
+    s[0] *= n[m];
+  s[1] = n[o];
+  for (let m = o + 1; m < n.length; m++)
+    s[2] *= n[m];
+  const i = /* @__PURE__ */ new Map(), u = new Int32Array(n[o]), a = new ct(s, r, e), h = [], c = s[0] === 1 && s[2] === 1;
+  for (let m = 0; m < n[o]; m++) {
+    let b;
+    if (c)
+      b = e[m].toString();
+    else {
+      const d = [];
+      for (let E = 0; E < s[0]; E++)
+        for (let R = 0; R < s[2]; R++)
+          d.push(a.get(E, m, R));
+      b = d.join(",");
+    }
+    const g = i.get(b);
+    if (g != null)
+      u[m] = g;
+    else {
+      const d = i.size;
+      i.set(b, d), u[m] = d, h.push(m);
+    }
+  }
+  const f = s.slice();
+  f[1] = i.size;
+  const p = new ct(f, r);
+  h.forEach((m, b) => {
+    for (let g = 0; g < s[0]; g++)
+      for (let d = 0; d < s[2]; d++)
+        p.set(a.get(g, m, d), g, b, d);
+  });
+  const I = n.slice();
+  return I[o] = f[1], {
+    outputValues: p.values,
+    outputShape: I,
+    indices: u
+  };
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const pn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  addImpl: de,
+  bincountImpl: me,
+  bincountReduceImpl: we,
+  bitwiseAndImpl: pe,
+  castImpl: ge,
+  ceilImpl: Ie,
+  concatImpl: Ee,
+  equalImpl: Se,
+  expImpl: Fe,
+  expm1Impl: be,
+  floorDivImpl: Re,
+  floorImpl: xe,
+  gatherNdImpl: Te,
+  gatherV2Impl: ve,
+  greaterEqualImpl: _e,
+  greaterImpl: Oe,
+  lessEqualImpl: Le,
+  lessImpl: ye,
+  linSpaceImpl: Me,
+  logImpl: Ne,
+  maxImpl: $e,
+  maximumImpl: Ae,
+  minimumImpl: De,
+  multiplyImpl: Ot,
+  negImpl: Pe,
+  notEqualImpl: We,
+  prodImpl: Ve,
+  raggedGatherImpl: Be,
+  raggedRangeImpl: ke,
+  raggedTensorToTensorImpl: He,
+  rangeImpl: Ke,
+  rsqrtImpl: Xe,
+  scatterImpl: Qe,
+  sigmoidImpl: Je,
+  simpleAbsImpl: fe,
+  sliceImpl: Ye,
+  sparseFillEmptyRowsImpl: tn,
+  sparseReshapeImpl: en,
+  sparseSegmentReductionImpl: nn,
+  sqrtImpl: rn,
+  squaredDifferenceImpl: on,
+  staticRegexReplaceImpl: sn,
+  stridedSliceImpl: ln,
+  stringNGramsImpl: an,
+  stringSplitImpl: cn,
+  stringToHashBucketFastImpl: fn,
+  subImpl: gn,
+  tileImpl: dn,
+  topKImpl: mn,
+  transposeImpl: qe,
+  uniqueImpl: wn
+}, Symbol.toStringTag, { value: "Module" }));
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const { logImpl: Tn, maxImpl: vn, transposeImpl: On } = pn;
+export {
+  Tn as l,
+  vn as m,
+  On as t
+};