@genai-fi/nanogpt 0.3.2 → 0.4.1

package/dist/tfjs_backend-Bzl2SrRo.js

@@ -0,0 +1,2460 @@
+import { o as p, h as l, E as d, af as oe, ag as ae, j as f, ah as ie, D as Cn, ai as ce, aj as v, ak as ue, al as le, am as fe, an as pe, a1 as he, ao as In, ap as de, p as Y, aq as me, ar as ge, as as $e, at as be, au as ke, av as xe, aw as we, ax as ye, x as L, ay as _e, az as Ae, k as zn, aA as Ie, aB as Ee, aC as Te, aD as Se, aE as Ne, aF as De, I as Me, J as Oe, K as Ve, aG as ve, t as P, aH as dn, aI as Pe, aa as Be, aJ as K, a5 as C, b as A, aK as Re, n as Vn, c as vn, aL as Pn, aM as Ke, aN as qe, aO as Fe, aP as je, aQ as Ge, aR as Le, f as Ce, aS as ze, aT as Ue, s as R, aU as Je, w as mn, a as We, ae as Bn, aV as Ye, $ as Xe } from "./index-XjBAhiFO.js";
+import { r as $ } from "./reshape-DFzh97Sc.js";
+import { s as Un } from "./split-CkbeVdF8.js";
+import { s as j } from "./sum-C6u3xMi3.js";
+import { b as gn } from "./slice_util-CnVNPQI-.js";
+import { r as ln } from "./range-DQMNzBWs.js";
+import { t as Ze } from "./tensor-Cu1fU7H7.js";
+import { s as fn } from "./stack-DaIMO5iX.js";
+import { c as He, z as Qe } from "./zeros-CmJFiC84.js";
+import { n as Jn } from "./norm-BzY929B_.js";
+import { c as G } from "./concat-DS_qH7MI.js";
+import { m as _ } from "./mat_mul-CKwFEV1Q.js";
+import { t as $n } from "./tensor2d-D0CKdG6B.js";
+import { s as Wn } from "./index-C4L8Cm77.js";
+import { g as nt } from "./gather-BUmJIS8n.js";
+/**
+ * @license
+ * Copyright 2018 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 et(n) {
+  const t = { x: l(n, "x", "sigmoid", "float32") };
+  return d.runKernel(oe, t);
+}
+const tt = /* @__PURE__ */ p({ sigmoid_: et });
+/**
+ * @license
+ * Copyright 2018 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 st(n, e, t) {
+  const s = l(n, "x", "slice", "string_or_numeric");
+  if (s.rank === 0)
+    throw new Error("Slicing scalar is not possible");
+  const r = { x: s }, o = { begin: e, size: t };
+  return d.runKernel(ae, r, o);
+}
+const I = /* @__PURE__ */ p({ slice_: st });
+/**
+ * @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 rt(n, e, t) {
+  const s = l(n, "x", "bincount"), r = l(e, "weights", "bincount");
+  f(s.dtype === "int32", () => `Error in bincount: input dtype must be int32, but got ${s.dtype}`), f(t >= 0, () => `size must be non-negative, but got ${t}.`), f(r.size === s.size || r.size === 0, () => `Error in bincount: weights must have the same size as input or0-length, but got input shape: ${s.shape}, weights shape: ${r.shape}.`);
+  const o = { x: s, weights: r }, a = { size: t };
+  return d.runKernel(ie, o, a);
+}
+const ot = /* @__PURE__ */ p({ bincount_: rt });
+/**
+ * @license
+ * Copyright 2018 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 at(n, e, t) {
+  const s = l(n, "x", "clipByValue");
+  if (f(e <= t, () => `Error in clip: min (${e}) must be less than or equal to max (${t}).`), e === t)
+    return Cn(s.shape, e, s.dtype);
+  const r = { x: s }, o = { clipValueMin: e, clipValueMax: t };
+  return d.runKernel(ce, r, o);
+}
+const it = /* @__PURE__ */ p({ clipByValue_: at });
+function ct(n) {
+  return G(
+    n,
+    0
+    /* axis */
+  );
+}
+const ut = /* @__PURE__ */ p({ concat1d_: ct });
+function lt(n, e) {
+  return G(n, e);
+}
+const ft = /* @__PURE__ */ p({ concat2d_: lt });
+function pt(n, e) {
+  return G(n, e);
+}
+const ht = /* @__PURE__ */ p({ concat3d_: pt });
+function dt(n, e) {
+  return G(n, e);
+}
+const mt = /* @__PURE__ */ p({ concat4d_: dt });
+/**
+ * @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 gt(n, e, t) {
+  const s = l(e, "a", "where"), r = l(t, "b", "where"), o = l(n, "condition", "where", "bool"), a = v(v(o.shape, s.shape), r.shape), i = gn(o, a), u = gn(s, a), c = gn(r, a), m = {
+    condition: i,
+    t: u,
+    e: c
+  };
+  return d.runKernel(ue, m);
+}
+const nn = /* @__PURE__ */ p({ where_: gt });
+/**
+ * @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 $t(n, ...e) {
+  const t = e.map((r, o) => l(r, `tensors${o}`, "einsum")), s = { equation: n };
+  return d.runKernel(le, t, s);
+}
+const rn = /* @__PURE__ */ p({ einsum_: $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 bt(n) {
+  const t = { x: l(n, "x", "elu", "float32") };
+  return d.runKernel(fe, t);
+}
+const Yn = /* @__PURE__ */ p({ elu_: bt });
+/**
+ * @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 kt(n, e = 0) {
+  const t = l(n, "x", "expandDims", "string_or_numeric");
+  f(e <= t.rank, () => "Axis must be <= rank of the tensor");
+  const s = { input: t }, r = { dim: e };
+  return d.runKernel(pe, s, r);
+}
+const W = /* @__PURE__ */ p({ expandDims_: kt });
+/**
+ * @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 xt(n, e) {
+  const t = l(n, "x", "tile", "string_or_numeric");
+  f(t.rank === e.length, () => `Error in transpose: rank of input ${t.rank} must match length of reps ${e}.`);
+  const s = { x: t }, r = { reps: e };
+  return d.runKernel(he, s, r);
+}
+const on = /* @__PURE__ */ p({ tile_: xt });
+/**
+ * @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 wt(n, e, t, s = "float32") {
+  e == null && (e = n);
+  const r = In([n, e], s), o = n <= e ? n : e;
+  for (let i = 0; i < o; ++i)
+    r.set(1, i, i);
+  const a = $(r.toTensor(), [n, e]);
+  if (t == null)
+    return a;
+  if (t.length === 1)
+    return on(W(a, 0), [t[0], 1, 1]);
+  if (t.length === 2)
+    return on(W(W(a, 0), 0), [t[0], t[1], 1, 1]);
+  if (t.length === 3)
+    return on(W(W(W(a, 0), 0), 0), [
+      t[0],
+      t[1],
+      t[2],
+      1,
+      1
+    ]);
+  throw new Error(`eye() currently supports only 1D and 2D batchShapes, but received ${t.length}D.`);
+}
+const yt = /* @__PURE__ */ p({ eye_: wt });
+/**
+ * @license
+ * Copyright 2018 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 _t(n) {
+  const t = { x: l(n, "x", "floor", "float32") };
+  return d.runKernel(de, t);
+}
+const At = /* @__PURE__ */ p({ floor_: _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 It(n, e) {
+  let t = l(n, "a", "greater", "string_or_numeric"), s = l(e, "b", "greater", "string_or_numeric");
+  [t, s] = Y(t, s), v(t.shape, s.shape);
+  const r = { a: t, b: s };
+  return d.runKernel(me, r);
+}
+const En = /* @__PURE__ */ p({ greater_: It });
+/**
+ * @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 Et(n, e) {
+  let t = l(n, "a", "greaterEqual", "string_or_numeric"), s = l(e, "b", "greaterEqual", "string_or_numeric");
+  [t, s] = Y(t, s), v(t.shape, s.shape);
+  const r = { a: t, b: s };
+  return d.runKernel(ge, r);
+}
+const Tt = /* @__PURE__ */ p({ greaterEqual_: Et });
+/**
+ * @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 St(n) {
+  const t = { input: l(n, "input", "imag") };
+  return d.runKernel($e, t);
+}
+const Nt = /* @__PURE__ */ p({ imag_: St });
+/**
+ * @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 Dt(n, e = 0.2) {
+  const s = { x: l(n, "x", "leakyRelu") }, r = { alpha: e };
+  return d.runKernel(be, s, r);
+}
+const Mt = /* @__PURE__ */ p({ leakyRelu_: Dt });
+/**
+ * @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 Ot(n, e) {
+  let t = l(n, "a", "less", "string_or_numeric"), s = l(e, "b", "less", "string_or_numeric");
+  [t, s] = Y(t, s), v(t.shape, s.shape);
+  const r = { a: t, b: s };
+  return d.runKernel(ke, r);
+}
+const Rn = /* @__PURE__ */ p({ less_: Ot });
+/**
+ * @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 Vt(n, e) {
+  let t = l(n, "a", "lessEqual", "string_or_numeric"), s = l(e, "b", "lessEqual", "string_or_numeric");
+  [t, s] = Y(t, s), v(t.shape, s.shape);
+  const r = { a: t, b: s };
+  return d.runKernel(xe, r);
+}
+const Xn = /* @__PURE__ */ p({ lessEqual_: Vt });
+/**
+ * @license
+ * Copyright 2018 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 vt(n) {
+  const t = { x: l(n, "x", "neg") };
+  return d.runKernel(we, t);
+}
+const Tn = /* @__PURE__ */ p({ neg_: vt });
+/**
+ * @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 Pt(n, e) {
+  const t = l(n, "a", "logicalAnd", "bool"), s = l(e, "b", "logicalAnd", "bool");
+  v(t.shape, s.shape);
+  const r = { a: t, b: s };
+  return d.runKernel(ye, r);
+}
+const Bt = /* @__PURE__ */ p({ logicalAnd_: Pt });
+/**
+ * @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 Rt(n, e) {
+  let t = l(n, "a", "minimum"), s = l(e, "b", "minimum");
+  [t, s] = Y(t, s), t.dtype === "bool" && (t = L(t, "int32"), s = L(s, "int32")), v(t.shape, s.shape);
+  const r = { a: t, b: s };
+  return d.runKernel(_e, r);
+}
+const Kn = /* @__PURE__ */ p({ minimum_: Rt });
+/**
+ * @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 Kt(n, e) {
+  const t = l(n, "x", "prelu"), s = l(e, "alpha", "prelu"), r = { x: t, alpha: s };
+  return d.runKernel(Ae, r);
+}
+const qt = /* @__PURE__ */ p({ prelu_: Kt });
+/**
+ * @license
+ * Copyright 2018 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 Ft {
+  constructor(e, t, s, r, o) {
+    this.mean = e, this.stdDev = t, this.dtype = s, this.nextVal = NaN, this.truncated = r, this.truncated && (this.upper = this.mean + this.stdDev * 2, this.lower = this.mean - this.stdDev * 2);
+    const a = o || Math.random();
+    this.random = Wn.alea(a.toString());
+  }
+  /** Returns next sample from a Gaussian distribution. */
+  nextValue() {
+    if (!isNaN(this.nextVal)) {
+      const r = this.nextVal;
+      return this.nextVal = NaN, r;
+    }
+    let e, t, s = !1;
+    for (; !s; ) {
+      let r, o, a;
+      do
+        r = 2 * this.random() - 1, o = 2 * this.random() - 1, a = r * r + o * o;
+      while (a >= 1 || a === 0);
+      const i = Math.sqrt(-2 * Math.log(a) / a);
+      e = this.mean + this.stdDev * r * i, t = this.mean + this.stdDev * o * i, (!this.truncated || this.isValidTruncated(e)) && (s = !0);
+    }
+    return (!this.truncated || this.isValidTruncated(t)) && (this.nextVal = this.convertValue(t)), this.convertValue(e);
+  }
+  /** Handles proper rounding for non-floating-point numbers. */
+  convertValue(e) {
+    return this.dtype == null || this.dtype === "float32" ? e : Math.round(e);
+  }
+  /** Returns true if less than 2-standard-deviations from the mean. */
+  isValidTruncated(e) {
+    return e <= this.upper && e >= this.lower;
+  }
+}
+class jt {
+  constructor(e = 0, t = 1, s, r) {
+    if (this.canReturnFloat = () => this.dtype == null || this.dtype === "float32", this.min = e, this.range = t - e, this.dtype = s, r == null && (r = Math.random()), typeof r == "number" && (r = r.toString()), !this.canReturnFloat() && this.range <= 1)
+      throw new Error(`The difference between ${e} - ${t} <= 1 and dtype is not float`);
+    this.random = Wn.alea(r);
+  }
+  convertValue(e) {
+    return this.canReturnFloat() ? e : Math.round(e);
+  }
+  nextValue() {
+    return this.convertValue(this.min + this.range * this.random());
+  }
+}
+/**
+ * @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 Gt(n, e = 0, t = 1, s, r) {
+  if (zn(n), s != null && s === "bool")
+    throw new Error(`Unsupported data type ${s}`);
+  const o = new Ft(e, t, s, !1, r), a = In(n, s);
+  for (let i = 0; i < a.values.length; i++)
+    a.values[i] = o.nextValue();
+  return a.toTensor();
+}
+const Lt = /* @__PURE__ */ p({ randomNormal_: Gt });
+/**
+ * @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 Ct(n, e = 0, t = 1, s = "float32", r) {
+  zn(n);
+  const o = In(n, s), a = new jt(e, t, null, r);
+  for (let i = 0; i < o.values.length; i++)
+    o.values[i] = a.nextValue();
+  return o.toTensor();
+}
+const zt = /* @__PURE__ */ p({ randomUniform_: Ct });
+/**
+ * @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 Ut(n) {
+  const t = { input: l(n, "input", "real") };
+  return d.runKernel(Ie, t);
+}
+const Jt = /* @__PURE__ */ p({ real_: Ut });
+/**
+ * @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 Wt(n) {
+  const t = { x: l(n, "x", "relu") };
+  return d.runKernel(Ee, t);
+}
+const Yt = /* @__PURE__ */ p({ relu_: Wt });
+/**
+ * @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 Xt(n) {
+  const t = { x: l(n, "x", "relu6") };
+  return d.runKernel(Te, t);
+}
+const Zt = /* @__PURE__ */ p({ relu6_: Xt });
+/**
+ * @license
+ * Copyright 2018 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 Ht(n) {
+  const t = { x: l(n, "x", "round") };
+  return d.runKernel(Se, t);
+}
+const Qt = /* @__PURE__ */ p({ round_: Ht });
+/**
+ * @license
+ * Copyright 2018 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 ns(n, e, t) {
+  const s = l(n, "x", "slice1d");
+  return f(s.rank === 1, () => `slice1d expects a rank-1 tensor, but got a rank-${s.rank} tensor`), I(s, [e], [t]);
+}
+const Sn = /* @__PURE__ */ p({ slice1d_: ns });
+/**
+ * @license
+ * Copyright 2018 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 es(n, e, t) {
+  const s = l(n, "x", "slice2d");
+  return f(s.rank === 2, () => `slice2d expects a rank-2 tensor, but got a rank-${s.rank} tensor`), I(s, e, t);
+}
+const Zn = /* @__PURE__ */ p({ slice2d_: es });
+/**
+ * @license
+ * Copyright 2018 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 ts(n, e, t) {
+  const s = l(n, "x", "slice3d");
+  return f(s.rank === 3, () => `slice3d expects a rank-3 tensor, but got a rank-${s.rank} tensor`), I(s, e, t);
+}
+const Nn = /* @__PURE__ */ p({ slice3d_: ts });
+/**
+ * @license
+ * Copyright 2018 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 ss(n, e, t) {
+  const s = l(n, "x", "slice4d");
+  return f(s.rank === 4, () => `slice4d expects a rank-4 tensor, but got a rank-${s.rank} tensor`), I(s, e, t);
+}
+const pn = /* @__PURE__ */ p({ slice4d_: ss });
+/**
+ * @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 rs(n, e) {
+  const t = l(n, "x", "squeeze", "string_or_numeric");
+  return $(t, Ne(t.shape, e).newShape);
+}
+const os = /* @__PURE__ */ p({ squeeze_: rs });
+/**
+ * @license
+ * Copyright 2018 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 as(n, e = 0) {
+  const s = { x: l(n, "x", "step") }, r = { alpha: e };
+  return d.runKernel(De, s, r);
+}
+const is = /* @__PURE__ */ p({ step_: as });
+/**
+ * @license
+ * Copyright 2018 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 V(n, e) {
+  Me(n);
+  const t = Oe(n, e);
+  if (t.length !== 1)
+    throw new Error("tensor1d() requires values to be a flat/TypedArray");
+  return Ve(n, null, t, 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 cs(n, e = 0) {
+  const t = l(n, "x", "unstack", "string_or_numeric");
+  f(e >= -t.shape.length && e < t.shape.length, () => `Axis = ${e} is not in [-${t.shape.length}, ${t.shape.length})`);
+  const s = { value: t }, r = { axis: e };
+  return d.runKernel(ve, s, r);
+}
+const Hn = /* @__PURE__ */ p({ unstack_: cs });
+/**
+ * @license
+ * Copyright 2018 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 us(n, e, t) {
+  const s = l(n, "x", "transpose");
+  if (e == null && (e = s.shape.map((a, i) => i).reverse()), f(s.rank === e.length, () => `Error in transpose: rank of input ${s.rank} must match length of perm ${e}.`), e.forEach((a) => {
+    f(a >= 0 && a < s.rank, () => `All entries in 'perm' must be between 0 and ${s.rank - 1} but got ${e}`);
+  }), s.rank <= 1)
+    return s.clone();
+  const r = { x: s }, o = { perm: e };
+  return s.dtype === "complex64" ? P(() => {
+    let a = Jt(s), i = Nt(s);
+    return a = d.runKernel(dn, { x: a }, o), i = d.runKernel(dn, { x: i }, o), t && (i = Tn(i)), He(a, i);
+  }) : d.runKernel(dn, r, o);
+}
+const wn = /* @__PURE__ */ p({ transpose_: us });
+/**
+ * @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 ls(n, e) {
+  if (e == null)
+    return n.shape.slice();
+  if (Pe(n.shape, e))
+    return e;
+  if (n.shape.length === e.length) {
+    const t = [];
+    for (let s = 0; s < n.shape.length; s++)
+      e[s] == null && n.shape[s] != null ? t.push(n.shape[s]) : t.push(e[s]);
+    return t;
+  }
+  return e;
+}
+/**
+ * @license
+ * Copyright 2018 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 fs(n, e, t, s) {
+  const r = l(n, "x", "dropout");
+  if (f(r.dtype === "float32", () => `x has to be a floating point tensor since it's going to be scaled, but got a ${r.dtype} tensor instead.`), f(e >= 0 && e < 1, () => `rate must be a float in the range [0, 1), but got ${e}.`), e === 0)
+    return n instanceof Be ? r.clone() : r;
+  const o = ls(r, t), a = 1 - e, i = K(At(C(zt(o, 0, 1, "float32", s), a)), a);
+  return A(r, i);
+}
+const ps = /* @__PURE__ */ p({ dropout_: fs });
+/**
+ * @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 hs(n, e, t) {
+  if (t == null || t === "linear")
+    return n;
+  if (t === "relu")
+    return A(n, is(e));
+  throw new Error(`Cannot compute gradient for fused activation ${t}.`);
+}
+function ds(n, e) {
+  let t = e;
+  const s = Re(n.shape, e.shape);
+  return s.length > 0 && (t = j(t, s)), $(t, n.shape);
+}
+function ms(n, e, t, s) {
+  if (e === "linear")
+    return n;
+  if (e === "relu")
+    return Yt(n);
+  if (e === "elu")
+    return Yn(n);
+  if (e === "relu6")
+    return Zt(n);
+  if (e === "prelu")
+    return qt(n, t);
+  if (e === "leakyrelu")
+    return Mt(n, s);
+  if (e === "sigmoid")
+    return tt(n);
+  throw new Error(`Unknown fused activation ${e}.`);
+}
+const gs = (n, e) => !(n > 0) || e === "linear";
+/**
+ * @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 $s({ a: n, b: e, transposeA: t = !1, transposeB: s = !1, bias: r, activation: o = "linear", preluActivationWeights: a, leakyreluAlpha: i = 0.2 }) {
+  if (gs(d.state.gradientDepth, o) === !1) {
+    let U = _(n, e, t, s);
+    return r != null && (U = C(U, r)), ms(U, o, a, i);
+  }
+  let u = l(n, "a", "fused matMul"), c = l(e, "b", "fused matMul");
+  [u, c] = Y(u, c);
+  const m = t ? u.shape[u.rank - 2] : u.shape[u.rank - 1], h = s ? c.shape[c.rank - 1] : c.shape[c.rank - 2], b = t ? u.shape[u.rank - 1] : u.shape[u.rank - 2], g = s ? c.shape[c.rank - 2] : c.shape[c.rank - 1], x = u.shape.slice(0, -2), w = c.shape.slice(0, -2), k = Vn(x), E = Vn(w);
+  f(m === h, () => `Error in fused matMul: inner shapes (${m}) and (${h}) of Tensors with shapes ${u.shape} and ${c.shape} and transposeA=${t} and transposeB=${s} must match.`);
+  const S = v(u.shape.slice(0, -2), c.shape.slice(0, -2)).concat([b, g]), M = t ? $(u, [k, m, b]) : $(u, [k, b, m]), O = s ? $(c, [E, g, h]) : $(c, [E, h, g]);
+  let N;
+  r != null && (N = l(r, "bias", "fused matMul"), [N] = Y(N, u), v(S, N.shape));
+  let tn;
+  a != null && (tn = l(a, "prelu weights", "fused matMul"));
+  const z = (U, sn) => {
+    const [q, F, J, un] = sn, B = hs($(U, J.shape), J, o);
+    let Z, H;
+    if (!t && !s ? (Z = _(B, F, !1, !0), H = _(q, B, !0, !1)) : !t && s ? (Z = _(B, F, !1, !1), H = _(B, q, !0, !1)) : t && !s ? (Z = _(F, B, !1, !0), H = _(q, B, !1, !1)) : (Z = _(F, B, !0, !0), H = _(B, q, !0, !0)), r != null) {
+      const re = ds(un, B);
+      return [Z, H, re];
+    } else
+      return [Z, H];
+  }, X = {
+    a: M,
+    b: O,
+    bias: N,
+    preluActivationWeights: tn
+  }, On = { transposeA: t, transposeB: s, activation: o, leakyreluAlpha: i };
+  return r == null ? vn((sn, q, F) => {
+    const J = (
+      // tslint:disable-next-line: no-unnecessary-type-assertion
+      d.runKernel(Pn, X, On)
+    );
+    return F([sn, q, J]), { value: $(J, S), gradFunc: z };
+  })(M, O) : vn((sn, q, F, J) => {
+    const un = (
+      // tslint:disable-next-line: no-unnecessary-type-assertion
+      d.runKernel(Pn, X, On)
+    );
+    return J([sn, q, un, F]), { value: $(un, S), gradFunc: z };
+  })(M, O, N);
+}
+const qn = /* @__PURE__ */ p({ fusedMatMul_: $s });
+/**
+ * @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 bs(n, e, t, s, r = "bilinear", o = 0) {
+  const a = l(n, "image", "cropAndResize"), i = l(e, "boxes", "cropAndResize", "float32"), u = l(t, "boxInd", "cropAndResize", "int32"), c = i.shape[0];
+  f(a.rank === 4, () => `Error in cropAndResize: image must be rank 4,but got rank ${a.rank}.`), f(i.rank === 2 && i.shape[1] === 4, () => `Error in cropAndResize: boxes must be have size [${c},4] but had shape ${i.shape}.`), f(u.rank === 1 && u.shape[0] === c, () => `Error in cropAndResize: boxInd must be have size [${c}] but had shape ${i.shape}.`), f(s.length === 2, () => `Error in cropAndResize: cropSize must be of length 2, but got length ${s.length}.`), f(s[0] >= 1 && s[1] >= 1, () => `cropSize must be atleast [1,1], but was ${s}`), f(r === "bilinear" || r === "nearest", () => `method must be bilinear or nearest, but was ${r}`);
+  const m = { image: a, boxes: i, boxInd: u }, h = { method: r, extrapolationValue: o, cropSize: s };
+  return d.runKernel(Ke, m, h);
+}
+const ks = /* @__PURE__ */ p({ cropAndResize_: bs });
+/**
+ * @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 xs(n) {
+  const e = l(n, "image", "flipLeftRight", "float32");
+  f(e.rank === 4, () => `Error in flipLeftRight: image must be rank 4,but got rank ${e.rank}.`);
+  const t = { image: e };
+  return d.runKernel(qe, t, {});
+}
+const ws = /* @__PURE__ */ p({ flipLeftRight_: xs });
+/**
+ * @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 ys(n) {
+  const e = l(n, "image", "grayscaleToRGB"), t = e.rank - 1, s = e.shape[t];
+  f(e.rank >= 2, () => `Error in grayscaleToRGB: images must be at least rank 2, but got rank ${e.rank}.`), f(s === 1, () => `Error in grayscaleToRGB: last dimension of a grayscale image should be size 1, but got size ${s}.`);
+  const r = new Array(e.rank);
+  return r.fill(1, 0, t), r[t] = 3, on(e, r);
+}
+const _s = /* @__PURE__ */ p({ grayscaleToRGB_: ys });
+/**
+ * @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.
+ * =============================================================================
+ */
+function As(n) {
+  const e = l(n, "image", "RGBToGrayscale"), t = e.rank - 1, s = e.shape[t];
+  f(e.rank >= 2, () => `Error in RGBToGrayscale: images must be at least rank 2, but got rank ${e.rank}.`), f(s === 3, () => `Error in RGBToGrayscale: last dimension of an RGB image should be size 3, but got size ${s}.`);
+  const r = e.dtype, o = L(e, "float32"), a = V([0.2989, 0.587, 0.114]);
+  let i;
+  switch (e.rank) {
+    case 2:
+      i = rn("ij,j->i", o, a);
+      break;
+    case 3:
+      i = rn("ijk,k->ij", o, a);
+      break;
+    case 4:
+      i = rn("ijkl,l->ijk", o, a);
+      break;
+    case 5:
+      i = rn("ijklm,m->ijkl", o, a);
+      break;
+    case 6:
+      i = rn("ijklmn,n->ijklm", o, a);
+      break;
+    default:
+      throw new Error("Not a valid tensor rank.");
+  }
+  return i = W(i, -1), L(i, r);
+}
+const Is = /* @__PURE__ */ p({ rgbToGrayscale_: As });
+/**
+ * @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 Es(n, e, t = 0, s = 0.5) {
+  const r = l(n, "image", "rotateWithOffset", "float32");
+  f(r.rank === 4, () => `Error in rotateWithOffset: image must be rank 4,but got rank ${r.rank}.`);
+  const o = { image: r }, a = { radians: e, fillValue: t, center: s };
+  return d.runKernel(Fe, o, a);
+}
+const Ts = /* @__PURE__ */ p({ rotateWithOffset_: Es });
+/**
+ * @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 en(n, e, t, s, r, o) {
+  s == null && (s = 0.5), r == null && (r = Number.NEGATIVE_INFINITY), o == null && (o = 0);
+  const a = n.shape[0];
+  return t = Math.min(t, a), f(0 <= s && s <= 1, () => `iouThreshold must be in [0, 1], but was '${s}'`), f(n.rank === 2, () => `boxes must be a 2D tensor, but was of rank '${n.rank}'`), f(n.shape[1] === 4, () => `boxes must have 4 columns, but 2nd dimension was ${n.shape[1]}`), f(e.rank === 1, () => "scores must be a 1D tensor"), f(e.shape[0] === a, () => `scores has incompatible shape with boxes. Expected ${a}, but was ${e.shape[0]}`), f(0 <= o && o <= 1, () => `softNmsSigma must be in [0, 1], but was '${o}'`), { maxOutputSize: t, iouThreshold: s, scoreThreshold: r, softNmsSigma: 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 Ss(n, e, t, s = 0.5, r = Number.NEGATIVE_INFINITY) {
+  const o = l(n, "boxes", "nonMaxSuppression", "float32"), a = l(e, "scores", "nonMaxSuppression", "float32"), i = en(o, a, t, s, r);
+  t = i.maxOutputSize, s = i.iouThreshold, r = i.scoreThreshold;
+  const u = { maxOutputSize: t, iouThreshold: s, scoreThreshold: r };
+  return d.runKernel(je, { boxes: o, scores: a }, u);
+}
+const Ns = /* @__PURE__ */ p({ nonMaxSuppression_: Ss });
+/**
+ * @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 Ds(n, e, t) {
+  const s = Ms(n, e, t), r = s < 0 ? -(s + 1) : s;
+  n.splice(r, 0, e);
+}
+function Ms(n, e, t) {
+  return Vs(n, e, t || Os);
+}
+function Os(n, e) {
+  return n > e ? 1 : n < e ? -1 : 0;
+}
+function Vs(n, e, t) {
+  let s = 0, r = n.length, o = 0, a = !1;
+  for (; s < r; ) {
+    o = s + (r - s >>> 1);
+    const i = t(e, n[o]);
+    i > 0 ? s = o + 1 : (r = o, a = !i);
+  }
+  return a ? s : -s - 1;
+}
+/**
+ * @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 vs(n, e, t, s, r) {
+  return Dn(
+    n,
+    e,
+    t,
+    s,
+    r,
+    0
+    /* softNmsSigma */
+  );
+}
+function Ps(n, e, t, s, r, o) {
+  return Dn(
+    n,
+    e,
+    t,
+    s,
+    r,
+    0,
+    !1,
+    o,
+    !0
+    /* returnValidOutputs */
+  );
+}
+function Bs(n, e, t, s, r, o) {
+  return Dn(
+    n,
+    e,
+    t,
+    s,
+    r,
+    o,
+    !0
+    /* returnScoresTensor */
+  );
+}
+function Dn(n, e, t, s, r, o, a = !1, i = !1, u = !1) {
+  const c = [];
+  for (let k = 0; k < e.length; k++)
+    e[k] > r && c.push({ score: e[k], boxIndex: k, suppressBeginIndex: 0 });
+  c.sort(Fn);
+  const m = o > 0 ? -0.5 / o : 0, h = [], b = [];
+  for (; h.length < t && c.length > 0; ) {
+    const k = c.pop(), { score: E, boxIndex: T, suppressBeginIndex: S } = k;
+    if (E < r)
+      break;
+    let M = !1;
+    for (let O = h.length - 1; O >= S; --O) {
+      const N = Rs(n, T, h[O]);
+      if (N >= s) {
+        M = !0;
+        break;
+      }
+      if (k.score = k.score * Ks(s, m, N), k.score <= r)
+        break;
+    }
+    k.suppressBeginIndex = h.length, M || (k.score === E ? (h.push(T), b.push(k.score)) : k.score > r && Ds(c, k, Fn));
+  }
+  const g = h.length, x = t - g;
+  i && x > 0 && (h.push(...new Array(x).fill(0)), b.push(...new Array(x).fill(0)));
+  const w = { selectedIndices: h };
+  return a && (w.selectedScores = b), u && (w.validOutputs = g), w;
+}
+function Rs(n, e, t) {
+  const s = n.subarray(e * 4, e * 4 + 4), r = n.subarray(t * 4, t * 4 + 4), o = Math.min(s[0], s[2]), a = Math.min(s[1], s[3]), i = Math.max(s[0], s[2]), u = Math.max(s[1], s[3]), c = Math.min(r[0], r[2]), m = Math.min(r[1], r[3]), h = Math.max(r[0], r[2]), b = Math.max(r[1], r[3]), g = (i - o) * (u - a), x = (h - c) * (b - m);
+  if (g <= 0 || x <= 0)
+    return 0;
+  const w = Math.max(o, c), k = Math.max(a, m), E = Math.min(i, h), T = Math.min(u, b), S = Math.max(E - w, 0) * Math.max(T - k, 0);
+  return S / (g + x - S);
+}
+function Ks(n, e, t) {
+  const s = Math.exp(e * t * t);
+  return t <= n ? s : 0;
+}
+function Fn(n, e) {
+  return n.score - e.score || n.score === e.score && e.boxIndex - n.boxIndex;
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+async function qs(n, e, t, s = 0.5, r = Number.NEGATIVE_INFINITY) {
+  const o = l(n, "boxes", "nonMaxSuppressionAsync"), a = l(e, "scores", "nonMaxSuppressionAsync"), i = en(o, a, t, s, r);
+  t = i.maxOutputSize, s = i.iouThreshold, r = i.scoreThreshold;
+  const u = await Promise.all([o.data(), a.data()]), c = u[0], m = u[1], { selectedIndices: h } = vs(c, m, t, s, r);
+  return o !== n && o.dispose(), a !== e && a.dispose(), V(h, "int32");
+}
+const Fs = qs;
+/**
+ * @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 js(n, e, t, s = 0.5, r = Number.NEGATIVE_INFINITY, o = 0) {
+  const a = l(n, "boxes", "nonMaxSuppression"), i = l(e, "scores", "nonMaxSuppression"), u = en(a, i, t, s, r, o);
+  t = u.maxOutputSize, s = u.iouThreshold, r = u.scoreThreshold, o = u.softNmsSigma;
+  const c = { boxes: a, scores: i }, m = { maxOutputSize: t, iouThreshold: s, scoreThreshold: r, softNmsSigma: o }, h = d.runKernel(Ge, c, m);
+  return { selectedIndices: h[0], selectedScores: h[1] };
+}
+const Gs = /* @__PURE__ */ p({ nonMaxSuppressionWithScore_: js });
+/**
+ * @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.
+ * =============================================================================
+ */
+async function Ls(n, e, t, s = 0.5, r = Number.NEGATIVE_INFINITY, o = 0) {
+  const a = l(n, "boxes", "nonMaxSuppressionAsync"), i = l(e, "scores", "nonMaxSuppressionAsync"), u = en(a, i, t, s, r, o);
+  t = u.maxOutputSize, s = u.iouThreshold, r = u.scoreThreshold, o = u.softNmsSigma;
+  const c = await Promise.all([a.data(), i.data()]), m = c[0], h = c[1], { selectedIndices: b, selectedScores: g } = Bs(m, h, t, s, r, o);
+  return a !== n && a.dispose(), i !== e && i.dispose(), {
+    selectedIndices: V(b, "int32"),
+    selectedScores: V(g)
+  };
+}
+const Cs = Ls;
+/**
+ * @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 zs(n, e, t, s = 0.5, r = Number.NEGATIVE_INFINITY, o = !1) {
+  const a = l(n, "boxes", "nonMaxSuppression"), i = l(e, "scores", "nonMaxSuppression"), u = en(
+    a,
+    i,
+    t,
+    s,
+    r,
+    null
+    /* softNmsSigma */
+  ), c = u.maxOutputSize, m = u.iouThreshold, h = u.scoreThreshold, b = { boxes: a, scores: i }, g = {
+    maxOutputSize: c,
+    iouThreshold: m,
+    scoreThreshold: h,
+    padToMaxOutputSize: o
+  }, x = d.runKernel(Le, b, g);
+  return { selectedIndices: x[0], validOutputs: x[1] };
+}
+const Us = /* @__PURE__ */ p({ nonMaxSuppressionPadded_: zs });
+/**
+ * @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.
+ * =============================================================================
+ */
+async function Js(n, e, t, s = 0.5, r = Number.NEGATIVE_INFINITY, o = !1) {
+  const a = l(n, "boxes", "nonMaxSuppressionAsync"), i = l(e, "scores", "nonMaxSuppressionAsync"), u = en(
+    a,
+    i,
+    t,
+    s,
+    r,
+    null
+    /* softNmsSigma */
+  ), c = u.maxOutputSize, m = u.iouThreshold, h = u.scoreThreshold, [b, g] = await Promise.all([a.data(), i.data()]), { selectedIndices: x, validOutputs: w } = Ps(b, g, c, m, h, o);
+  return a !== n && a.dispose(), i !== e && i.dispose(), {
+    selectedIndices: V(x, "int32"),
+    validOutputs: Ce(w, "int32")
+  };
+}
+const Ws = Js;
+/**
+ * @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 Ys(n, e, t = !1, s = !1) {
+  const r = l(n, "images", "resizeBilinear");
+  f(r.rank === 3 || r.rank === 4, () => `Error in resizeBilinear: x must be rank 3 or 4, but got rank ${r.rank}.`), f(e.length === 2, () => `Error in resizeBilinear: new shape must 2D, but got shape ${e}.`), f(s === !1 || t === !1, () => "Error in resizeBilinear: If halfPixelCenters is true, alignCorners must be false.");
+  let o = r, a = !1;
+  r.rank === 3 && (a = !0, o = $(r, [1, r.shape[0], r.shape[1], r.shape[2]]));
+  const i = { images: o }, u = { alignCorners: t, halfPixelCenters: s, size: e }, c = d.runKernel(ze, i, u);
+  return a ? $(c, [c.shape[1], c.shape[2], c.shape[3]]) : c;
+}
+const Xs = /* @__PURE__ */ p({ resizeBilinear_: Ys });
+/**
+ * @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 Zs(n, e, t = !1, s = !1) {
+  const r = l(n, "images", "resizeNearestNeighbor");
+  f(r.rank === 3 || r.rank === 4, () => `Error in resizeNearestNeighbor: x must be rank 3 or 4, but got rank ${r.rank}.`), f(e.length === 2, () => `Error in resizeNearestNeighbor: new shape must 2D, but got shape ${e}.`), f(r.dtype === "float32" || r.dtype === "int32", () => "`images` must have `int32` or `float32` as dtype"), f(s === !1 || t === !1, () => "Error in resizeNearestNeighbor: If halfPixelCenters is true, alignCorners must be false.");
+  let o = r, a = !1;
+  r.rank === 3 && (a = !0, o = $(r, [1, r.shape[0], r.shape[1], r.shape[2]]));
+  const i = { images: o }, u = { alignCorners: t, halfPixelCenters: s, size: e }, c = d.runKernel(Ue, i, u);
+  return a ? $(c, [c.shape[1], c.shape[2], c.shape[3]]) : c;
+}
+const Hs = /* @__PURE__ */ p({ resizeNearestNeighbor_: Zs });
+/**
+ * @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
+ *
+ * https://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 Qs(n, e = "binary", t = !1, s = 0.5) {
+  const r = l(n, "image", "threshold"), o = 0.2989, a = 0.587, i = 0.114, u = r.shape[0] * r.shape[1];
+  let c = A(V([s]), 255), m, h, b, g;
+  if (f(r.rank === 3, () => `Error in threshold: image must be rank 3,but got rank ${r.rank}.`), f(r.shape[2] === 3 || r.shape[2] === 1, () => `Error in threshold: image color channel must be equal to 3 or 1but got ${r.shape[2]}.`), f(r.dtype === "int32" || r.dtype === "float32", () => `Error in dtype: image dtype must be int32 or float32,but got dtype ${r.dtype}.`), f(e === "otsu" || e === "binary", () => `Method must be binary or otsu, but was ${e}`), r.shape[2] === 3) {
+    [m, h, b] = Un(r, [1, 1, 1], -1);
+    const k = A(m, o), E = A(h, a), T = A(b, i);
+    g = C(C(k, E), T);
+  } else
+    g = n;
+  if (e === "otsu") {
+    const k = ot(L(Qt(g), "int32"), Ze([]), 256);
+    c = nr(k, u);
+  }
+  const x = t ? Xn(g, c) : En(g, c);
+  return L(A(x, 255), "int32");
+}
+function nr(n, e) {
+  let t = V([-1]), s = V([0]), r = V([0]), o, a, i, u, c, m;
+  for (let h = 0; h < n.size - 1; h++) {
+    o = I(n, 0, h + 1), a = I(n, h + 1), c = K(j(o), e), m = K(j(a), e);
+    const b = j(A(o, ln(0, o.size)));
+    i = K(b, j(o));
+    const g = Cn(a.shape, o.size), x = C(ln(0, a.size), g), w = A(a, x);
+    u = K(j(w), j(a));
+    const k = R(i, u), E = R(i, u), T = A(c, m);
+    r = A(A(T, k), E);
+    const S = En(r, s);
+    s = nn(S, r, s), t = nn(S, V([h]), t);
+  }
+  return t;
+}
+const er = /* @__PURE__ */ p({ threshold_: Qs });
+/**
+ * @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 tr(n, e, t = "nearest", s = "constant", r = 0, o) {
+  const a = l(n, "image", "transform", "float32"), i = l(e, "transforms", "transform", "float32");
+  f(a.rank === 4, () => `Error in transform: image must be rank 4,but got rank ${a.rank}.`), f(i.rank === 2 && (i.shape[0] === a.shape[0] || i.shape[0] === 1) && i.shape[1] === 8, () => "Error in transform: Input transform should be batch x 8 or 1 x 8"), f(o == null || o.length === 2, () => `Error in transform: outputShape must be [height, width] or null, but got ${o}.`);
+  const u = { image: a, transforms: i }, c = { interpolation: t, fillMode: s, fillValue: r, outputShape: o };
+  return d.runKernel(Je, u, c);
+}
+const sr = /* @__PURE__ */ p({ transform_: tr });
+/**
+ * @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 rr(n, e, t) {
+  const s = l(n, "a", "bandPart");
+  f(s.rank >= 2, () => `bandPart(): Rank must be at least 2, got ${s.rank}.`);
+  const r = s.shape, [o, a] = s.shape.slice(-2);
+  let i, u;
+  typeof e == "number" ? (f(e % 1 === 0, () => `bandPart(): numLower must be an integer, got ${e}.`), f(e <= o, () => `bandPart(): numLower (${e}) must not be greater than the number of rows (${o}).`), i = l(e < 0 ? o : e, "numLower", "bandPart")) : (f(e.dtype === "int32", () => "bandPart(): numLower's dtype must be an int32."), i = nn(Rn(e, 0), o, Kn(e, o))), typeof t == "number" ? (f(t % 1 === 0, () => `bandPart(): numUpper must be an integer, got ${t}.`), f(t <= a, () => `bandPart(): numUpper (${t}) must not be greater than the number of columns (${a}).`), u = l(t < 0 ? a : t, "numUpper", "bandPart")) : (f(t.dtype === "int32", () => "bandPart(): numUpper's dtype must be an int32."), u = nn(Rn(t, 0), a, Kn(t, a)));
+  const c = $(ln(0, o, 1, "int32"), [-1, 1]), m = ln(0, a, 1, "int32"), h = R(c, m), b = Bt(Xn(h, i), Tt(h, Tn(u))), g = Qe([o, a], s.dtype);
+  return $(fn(Hn($(s, [-1, o, a])).map((x) => nn(b, x, g))), r);
+}
+const or = /* @__PURE__ */ p({ bandPart_: rr });
+/**
+ * @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 ar(n) {
+  let e;
+  if (Array.isArray(n)) {
+    e = !1, f(n != null && n.length > 0, () => "Gram-Schmidt process: input must not be null, undefined, or empty");
+    const r = n[0].shape[0];
+    for (let o = 1; o < n.length; ++o)
+      f(n[o].shape[0] === r, () => `Gram-Schmidt: Non-unique lengths found in the input vectors: (${n[o].shape[0]} vs. ${r})`);
+  } else
+    e = !0, n = Un(n, n.shape[0], 0).map((r) => os(r, [0]));
+  f(n.length <= n[0].shape[0], () => `Gram-Schmidt: Number of vectors (${n.length}) exceeds number of dimensions (${n[0].shape[0]}).`);
+  const t = [], s = n;
+  for (let r = 0; r < n.length; ++r)
+    t.push(d.tidy(() => {
+      let o = s[r];
+      if (r > 0)
+        for (let a = 0; a < r; ++a) {
+          const i = A(j(A(t[a], o)), t[a]);
+          o = R(o, i);
+        }
+      return K(o, Jn(o, "euclidean"));
+    }));
+  return e ? fn(t, 0) : t;
+}
+const ir = /* @__PURE__ */ p({ gramSchmidt_: ar });
+/**
+ * @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 cr(n, e = !1) {
+  if (f(n.rank >= 2, () => `qr() requires input tensor to have a rank >= 2, but got rank ${n.rank}`), n.rank === 2)
+    return jn(n, e);
+  {
+    const t = n.shape.slice(0, n.shape.length - 2).reduce((u, c) => u * c), s = Hn($(n, [
+      t,
+      n.shape[n.shape.length - 2],
+      n.shape[n.shape.length - 1]
+    ]), 0), r = [], o = [];
+    s.forEach((u) => {
+      const [c, m] = jn(u, e);
+      r.push(c), o.push(m);
+    });
+    const a = $(fn(r, 0), n.shape), i = $(fn(o, 0), n.shape);
+    return [a, i];
+  }
+}
+function jn(n, e = !1) {
+  return d.tidy(() => {
+    f(n.shape.length === 2, () => `qr2d() requires a 2D Tensor, but got a ${n.shape.length}D Tensor.`);
+    const t = n.shape[0], s = n.shape[1];
+    let r = yt(t), o = mn(n);
+    const a = $n([[1]], [1, 1]);
+    let i = mn(a);
+    const u = t >= s ? s : t;
+    for (let c = 0; c < u; ++c) {
+      const m = o, h = i, b = r;
+      [i, o, r] = d.tidy(() => {
+        const g = I(o, [c, c], [t - c, 1]), x = Jn(g), w = I(o, [c, c], [1, 1]), k = nn(En(w, 0), $n([[-1]]), $n([[1]])), E = R(w, A(k, x)), T = K(g, E);
+        T.shape[0] === 1 ? i = mn(a) : i = G([
+          a,
+          I(T, [1, 0], [T.shape[0] - 1, T.shape[1]])
+        ], 0);
+        const S = Tn(K(_(k, E), x)), M = I(o, [c, 0], [t - c, s]), O = A(S, i), N = wn(i);
+        if (c === 0)
+          o = R(M, _(O, _(N, M)));
+        else {
+          const X = R(M, _(O, _(N, M)));
+          o = G([I(o, [0, 0], [c, s]), X], 0);
+        }
+        const tn = wn(O), z = I(r, [0, c], [t, r.shape[1] - c]);
+        if (c === 0)
+          r = R(z, _(_(z, i), tn));
+        else {
+          const X = R(z, _(_(z, i), tn));
+          r = G([I(r, [0, 0], [t, c]), X], 1);
+        }
+        return [i, o, r];
+      }), We([m, h, b]);
+    }
+    return !e && t > s && (r = I(r, [0, 0], [t, s]), o = I(o, [0, 0], [s, s])), [r, o];
+  });
+}
+const ur = /* @__PURE__ */ p({ qr_: cr });
+/**
+ * @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 Br = {
+  flipLeftRight: ws,
+  grayscaleToRGB: _s,
+  resizeNearestNeighbor: Hs,
+  resizeBilinear: Xs,
+  rgbToGrayscale: Is,
+  rotateWithOffset: Ts,
+  cropAndResize: ks,
+  nonMaxSuppression: Ns,
+  nonMaxSuppressionAsync: Fs,
+  nonMaxSuppressionWithScore: Gs,
+  nonMaxSuppressionWithScoreAsync: Cs,
+  nonMaxSuppressionPadded: Us,
+  nonMaxSuppressionPaddedAsync: Ws,
+  threshold: er,
+  transform: sr
+}, Rr = {
+  bandPart: or,
+  gramSchmidt: ir,
+  qr: ur
+};
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+const lr = ["channelsFirst", "channelsLast"], fr = ["nearest", "bilinear"], pr = ["valid", "same", "causal"], hr = ["max", "avg"], Kr = ["sum", "mul", "concat", "ave"];
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+class Qn extends Error {
+  constructor(e) {
+    super(e), Object.setPrototypeOf(this, Qn.prototype);
+  }
+}
+class ne extends Error {
+  constructor(e) {
+    super(e), Object.setPrototypeOf(this, ne.prototype);
+  }
+}
+class y extends Error {
+  constructor(e) {
+    super(e), Object.setPrototypeOf(this, y.prototype);
+  }
+}
+class cn extends Error {
+  constructor(e) {
+    super(e), Object.setPrototypeOf(this, cn.prototype);
+  }
+}
+class Mn extends Error {
+  constructor(e) {
+    super(e), Object.setPrototypeOf(this, Mn.prototype);
+  }
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+function qr(n, e) {
+  if (Array.isArray(n)) {
+    let t = [];
+    for (let s = 0; s < e; s++)
+      t = t.concat(n);
+    return t;
+  } else {
+    const t = new Array(e);
+    return t.fill(n), t;
+  }
+}
+function Gn(n, e) {
+  if (!n)
+    throw new Mn(e);
+}
+function Fr(n, e) {
+  let t = 0;
+  for (const s of n)
+    s === e && t++;
+  return t;
+}
+function jr(n) {
+  return n.length === 1 ? n[0] : n;
+}
+function Gr(n) {
+  return Array.isArray(n) ? n : [n];
+}
+function Lr(n) {
+  const t = n.replace(/(.)([A-Z][a-z0-9]+)/g, "$1_$2").replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+  return t[0] !== "_" ? t : "private" + t;
+}
+function Cr(n) {
+  return n.length <= 1 || n.indexOf("_") === -1 ? n : n.replace(/[_]+(\w|$)/g, (e, t) => t.toUpperCase());
+}
+let D = {};
+function zr(n) {
+  if (n == null)
+    return null;
+  const e = {};
+  return e.className = n.getClassName(), e.config = n.getConfig(), e;
+}
+function yn(n) {
+  if (!(n == null || typeof n != "object"))
+    if (Array.isArray(n))
+      n.forEach((e) => yn(e));
+    else {
+      const e = Object.keys(n);
+      for (const t of e) {
+        const s = n[t];
+        s != null && typeof s == "object" && (!Array.isArray(s) && s.type === "ndarray" && typeof s.value == "number" ? n[t] = s.value : yn(s));
+      }
+    }
+}
+function Ur(n, e = {}, t = {}, s = "object", r = !1) {
+  if (typeof n == "string") {
+    const o = n;
+    let a;
+    if (o in t)
+      a = t[o];
+    else if (o in D)
+      a = D[o];
+    else if (a = e[o], a == null)
+      throw new y(`Unknown ${s}: ${n}. This may be due to one of the following reasons:
+1. The ${s} is defined in Python, in which case it needs to be ported to TensorFlow.js or your JavaScript code.
+2. The custom ${s} is defined in JavaScript, but is not registered properly with tf.serialization.registerClass().`);
+    return a;
+  } else {
+    const o = n;
+    if (o.className == null || o.config == null)
+      throw new y(`${s}: Improper config format: ${JSON.stringify(o)}.
+'className' and 'config' must set.`);
+    const a = o.className;
+    let i, u;
+    if (a in t ? [i, u] = t[a] : a in D ? [i, u] = D.className : a in e && ([i, u] = e[a]), i == null)
+      throw new y(`Unknown ${s}: ${a}. This may be due to one of the following reasons:
+1. The ${s} is defined in Python, in which case it needs to be ported to TensorFlow.js or your JavaScript code.
+2. The custom ${s} is defined in JavaScript, but is not registered properly with tf.serialization.registerClass().`);
+    if (u != null) {
+      const c = {};
+      for (const g of Object.keys(D))
+        c[g] = D[g];
+      for (const g of Object.keys(t))
+        c[g] = t[g];
+      const m = o.config;
+      m.customObjects = c;
+      const h = Object.assign({}, D);
+      for (const g of Object.keys(t))
+        D[g] = t[g];
+      yn(o.config);
+      const b = u(i, o.config, t, r);
+      return D = Object.assign({}, h), b;
+    } else {
+      const c = Object.assign({}, D);
+      for (const h of Object.keys(t))
+        D[h] = t[h];
+      const m = new i(o.config);
+      return D = Object.assign({}, c), m;
+    }
+  }
+}
+function dr(n, e) {
+  return n < e ? -1 : n > e ? 1 : 0;
+}
+function Jr(n, e) {
+  return -1 * dr(n, e);
+}
+function Wr(n) {
+  if (n == null)
+    return n;
+  const e = [];
+  for (const t of n)
+    e.indexOf(t) === -1 && e.push(t);
+  return e;
+}
+function Yr(n) {
+  if (n == null)
+    throw new y(`Invalid value in obj: ${JSON.stringify(n)}`);
+  for (const e in n)
+    if (n.hasOwnProperty(e))
+      return !1;
+  return !0;
+}
+function hn(n, e, t) {
+  if (t != null && n.indexOf(t) < 0)
+    throw new y(`${t} is not a valid ${e}.  Valid values are ${n} or null/undefined.`);
+}
+function Xr(n, e, t = 0, s = 1 / 0) {
+  return Gn(t >= 0), Gn(s >= t), Array.isArray(n) && n.length >= t && n.length <= s && n.every((r) => typeof r === e);
+}
+function mr(n, e) {
+  Array.isArray(n) ? (f(n.length > 0, () => `${e} is unexpectedly an empty array.`), n.forEach((t, s) => mr(t, `element ${s + 1} of ${e}`))) : f(Number.isInteger(n) && n > 0, () => `Expected ${e} to be a positive integer, but got ${ee(n)}.`);
+}
+function ee(n) {
+  return n === null ? "null" : Array.isArray(n) ? "[" + n.map((e) => ee(e)).join(",") + "]" : typeof n == "string" ? `"${n}"` : `${n}`;
+}
+function Zr(n, e, t) {
+  let s = t != null ? t() : Bn(), r;
+  return (...a) => {
+    const i = t != null ? t() : Bn();
+    return i - s < e || (s = i, r = n(...a)), r;
+  };
+}
+function Hr(n) {
+  return n === "relu" ? "relu" : n === "linear" ? "linear" : n === "elu" ? "elu" : null;
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+const Q = /* @__PURE__ */ new Map();
+function gr(n) {
+  hn(lr, "DataFormat", n);
+}
+function Qr(n) {
+  hn(fr, "InterpolationFormat", n);
+}
+function no(n) {
+  hn(pr, "PaddingMode", n);
+}
+function eo(n) {
+  hn(hr, "PoolMode", n);
+}
+const an = [], Ln = "/";
+function to(n, e) {
+  an.push(n);
+  try {
+    const t = e();
+    return an.pop(), t;
+  } catch (t) {
+    throw an.pop(), t;
+  }
+}
+function $r() {
+  return an.length === 0 ? "" : an.join(Ln) + Ln;
+}
+function so(n) {
+  if (!te(n))
+    throw new Error("Not a valid tensor name: '" + n + "'");
+  return $r() + n;
+}
+function ro(n) {
+  if (!te(n))
+    throw new Error("Not a valid tensor name: '" + n + "'");
+  Q.has(n) || Q.set(n, 0);
+  const e = Q.get(n);
+  if (Q.set(n, Q.get(n) + 1), e > 0) {
+    const t = `${n}_${e}`;
+    return Q.set(t, 1), t;
+  } else
+    return n;
+}
+const br = new RegExp(/^[A-Za-z0-9][-A-Za-z0-9\._\/]*$/);
+function te(n) {
+  return !!n.match(br);
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+function oo(n) {
+  return n === parseInt(n.toString(), 10);
+}
+function se(n, e, t) {
+  e == null && (e = 0), t == null && (t = n.length);
+  let s = 1;
+  for (let r = e; r < t; ++r)
+    s *= n[r];
+  return s;
+}
+function ao(n) {
+  if (n.length === 0)
+    return Number.NaN;
+  let e = Number.POSITIVE_INFINITY;
+  for (let t = 0; t < n.length; t++) {
+    const s = n[t];
+    s < e && (e = s);
+  }
+  return e;
+}
+function io(n) {
+  if (n.length === 0)
+    return Number.NaN;
+  let e = Number.NEGATIVE_INFINITY;
+  for (let t = 0; t < n.length; t++) {
+    const s = n[t];
+    s > e && (e = s);
+  }
+  return e;
+}
+function co(n, e) {
+  if (e < n)
+    throw new y(`end (${e}) < begin (${n}) is forbidden.`);
+  const t = [];
+  for (let s = n; s < e; ++s)
+    t.push(s);
+  return t;
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+let bn;
+function uo() {
+  return bn == null && (bn = Ye().epsilon()), bn;
+}
+function _n() {
+  return "channelsLast";
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+function lo(n, e) {
+  return L(n, e);
+}
+function kr(n, e = -1) {
+  const t = n.shape.slice();
+  return e < 0 && (e = t.length + e + 1), t.splice(e, 0, 1), $(n, t);
+}
+function fo(n, e) {
+  return P(() => {
+    if (n.shape.length !== 2)
+      throw new y(`repeat() expects a rank-2 tensor, but received a rank-${n.shape.length} tensor.`);
+    const t = kr(n, 1);
+    return xr(t, [1, e, 1]);
+  });
+}
+function po(n) {
+  const e = [se(n.shape)];
+  return $(n, e);
+}
+function ho(n) {
+  if (n.rank <= 1)
+    throw new y(`batchFlatten requires a minimum rank of 2. Got rank: ${n.rank}.`);
+  const e = [n.shape[0], se(n.shape, 1)];
+  return $(n, e);
+}
+function kn(n, e, t) {
+  return P(() => {
+    switch (n.rank) {
+      case 1:
+        return Sn(n, e, t);
+      case 2:
+        return Zn(n, [e, 0], [t, n.shape[1]]);
+      case 3:
+        return Nn(n, [e, 0, 0], [t, n.shape[1], n.shape[2]]);
+      case 4:
+        return pn(n, [e, 0, 0, 0], [t, n.shape[1], n.shape[2], n.shape[3]]);
+      case 5:
+        return I(n, [e, 0, 0, 0, 0], [
+          t,
+          n.shape[1],
+          n.shape[2],
+          n.shape[3],
+          n.shape[4]
+        ]);
+      case 6:
+        return I(n, [e, 0, 0, 0, 0, 0], [
+          t,
+          n.shape[1],
+          n.shape[2],
+          n.shape[3],
+          n.shape[4],
+          n.shape[5]
+        ]);
+      default:
+        throw new y(`sliceAlongFirstAxis() received an unsupported tensor rank: ${n.rank}`);
+    }
+  });
+}
+function xn(n, e, t) {
+  return P(() => {
+    switch (n.rank) {
+      case 1:
+        return Sn(n, e, t);
+      case 2:
+        return Zn(n, [0, e], [n.shape[0], t]);
+      case 3:
+        return Nn(n, [0, 0, e], [n.shape[0], n.shape[1], t]);
+      case 4:
+        return pn(n, [0, 0, 0, e], [n.shape[0], n.shape[1], n.shape[2], t]);
+      default:
+        throw new y(`sliceAlongLastAxis() received an unsupported tensor rank: ${n.rank}`);
+    }
+  });
+}
+function mo(n, e, t, s) {
+  return P(() => {
+    switch (n.rank) {
+      case 1:
+        return Sn(n, e, t);
+      case 2:
+        switch (s) {
+          case 1:
+            return kn(n, e, t);
+          case 2:
+            return xn(n, e, t);
+          default:
+            throw new y(`The axis is not within the rank of the tensor ${s}`);
+        }
+      case 3:
+        switch (s) {
+          case 1:
+            return kn(n, e, t);
+          case 2:
+            return Nn(n, [0, e, 0], [n.shape[0], t, n.shape[2]]);
+          case 3:
+            return xn(n, e, t);
+          default:
+            throw new y(`The axis is not within the rank of the tensor ${s}`);
+        }
+      case 4:
+        switch (s) {
+          case 1:
+            return kn(n, e, t);
+          case 2:
+            return pn(n, [0, e, 0, 0], [n.shape[0], t, n.shape[2], n.shape[3]]);
+          case 3:
+            return pn(n, [0, 0, e, 0], [n.shape[0], n.shape[1], t, n.shape[3]]);
+          case 4:
+            return xn(n, e, t);
+          default:
+            throw new y(`The axis is not within the rank of the tensor ${s}`);
+        }
+      default:
+        throw new y(`sliceAlongLastAxis() received an unsupported tensor rank: ${n.rank}`);
+    }
+  });
+}
+function go(n, e = -1) {
+  let t;
+  return e < 0 && (t = n[0].rank, t !== 0 ? e = t : e = 0), e === n[0].rank && (e = -1), G(n, e);
+}
+function $o(n, e) {
+  switch (n.rank) {
+    case 1:
+      return ut([n, e]);
+    case 2:
+      return ft([n, e], 0);
+    case 3:
+      return ht([n, e], 0);
+    case 4:
+      return mt([n, e], 0);
+    default:
+      throw new y(`concatAlongFirstAxis() received an unsupported tensor rank: ${n.rank}`);
+  }
+}
+function xr(n, e) {
+  if (Array.isArray(e) || (e = [e]), n.rank !== e.length)
+    throw new y(`The length of input n (${e.length}) does not match the number of dimensions in input x (${n.rank})`);
+  return on(n, e);
+}
+function bo(n, e = 0, t = 1, s, r) {
+  return Lt(n, e, t, s, r);
+}
+function ko(n, e, t, s) {
+  if (n.rank < 2 || e.rank < 2)
+    throw new cn(`dot requires both inputs to be rank >= 2 but got x shape = ${n.shape} and y shape = ${e.shape}`);
+  if (e.rank >= 3) {
+    const r = n.shape.slice(-1)[0], o = e.shape.slice(-2)[0];
+    if (r !== o)
+      throw new cn(`If rank y >= 3, then the second last dim of y must equal the last dim of x but got x shape = ${n.shape} and  y shape = ${e.shape}`);
+  }
+  if (n.rank === 2 && e.rank === 2)
+    return qn({
+      a: n,
+      b: e,
+      transposeA: !1,
+      transposeB: !1,
+      bias: s ? An(n.rank, s, _n()) : null,
+      activation: t
+    });
+  {
+    const r = n.shape.slice(), o = r.pop();
+    n = $(n, [-1, o]);
+    const a = e.shape.slice(), i = a.pop(), u = a.pop(), c = [...a, i], m = Array.from({ length: e.rank }, (x, w) => w === 0 ? e.rank - 2 : w <= e.rank - 2 ? w - 1 : w);
+    e = $(wn(e, m), [u, -1]);
+    const h = [...r, ...c];
+    return $(qn({
+      a: n,
+      b: e,
+      transposeA: !1,
+      transposeB: !1,
+      bias: s ? An(n.rank, s, _n()) : null,
+      activation: t
+    }), h);
+  }
+}
+function xo(n, e, t) {
+  return P(() => (Array.isArray(e) ? e = V(e, "int32") : e = L(e, "int32"), nt(n, e, t)));
+}
+function wo(n) {
+  return A(n, n);
+}
+function An(n, e, t) {
+  const s = e.shape;
+  if (e.rank !== 1 && e.rank !== n)
+    throw new y(`Unexpected bias dimensions: ${e.rank}; expected it to be 1 or ${n}`);
+  if (n === 5) {
+    if (t === "channelsFirst")
+      return s.length === 1 ? $(e, [1, s[0], 1, 1, 1]) : $(e, [1, s[3], s[0], s[1], s[2]]);
+    if (t === "channelsLast")
+      return s.length === 1 ? $(e, [1, 1, 1, 1, s[0]]) : $(e, [1].concat(s));
+  } else if (n === 4) {
+    if (t === "channelsFirst")
+      return s.length === 1 ? $(e, [1, s[0], 1, 1]) : $(e, [1, s[2], s[0], s[1]]);
+    if (t === "channelsLast")
+      return s.length === 1 ? $(e, [1, 1, 1, s[0]]) : $(e, [1].concat(s));
+  } else if (n === 3) {
+    if (t === "channelsFirst")
+      return s.length === 1 ? $(e, [1, s[0], 1]) : $(e, [1, s[1], s[0]]);
+    if (t === "channelsLast")
+      return s.length === 1 ? $(e, [1, 1, s[0]]) : $(e, [1].concat(s));
+  } else if (n < 3)
+    return e;
+  throw new y(`Unsupported input rank by biasAdd: ${e.rank}`);
+}
+function yo(n, e, t) {
+  return P(() => (t == null && (t = _n()), gr(t), C(n, An(n.rank, e, t))));
+}
+function _o(n, e = 1) {
+  if (e !== 1)
+    throw new cn(`Support for alpha values other than 1 (${e}) is not implemented yet.`);
+  return Yn(n);
+}
+function Ao(n) {
+  return P(() => K(n, C(Xe(n), 1)));
+}
+function Io(n, e, t, s) {
+  return P(() => ps(n, e, t, s));
+}
+function Eo(n) {
+  return P(() => {
+    const e = C(0.5, A(0.2, n));
+    return it(e, 0, 1);
+  });
+}
+function To(n, e, t = !1) {
+  return t ? n() : e();
+}
+export {
+  Jr as $,
+  Qn as A,
+  Tt as B,
+  Xn as C,
+  wn as D,
+  on as E,
+  En as F,
+  Rn as G,
+  I as H,
+  At as I,
+  Hn as J,
+  tt as K,
+  W as L,
+  Ft as M,
+  cn as N,
+  it as O,
+  uo as P,
+  Yt as Q,
+  ne as R,
+  Zr as S,
+  po as T,
+  wo as U,
+  y as V,
+  Gn as W,
+  lo as X,
+  os as Y,
+  Cr as Z,
+  Wr as _,
+  ps as a,
+  qr as a0,
+  Yr as a1,
+  V as a2,
+  kn as a3,
+  kr as a4,
+  xo as a5,
+  co as a6,
+  Fr as a7,
+  _o as a8,
+  Kn as a9,
+  Eo as aa,
+  Ao as ab,
+  Mt as ac,
+  qt as ad,
+  Yn as ae,
+  io as af,
+  oo as ag,
+  Xr as ah,
+  yo as ai,
+  mo as aj,
+  Qr as ak,
+  Br as al,
+  mr as am,
+  Hr as an,
+  no as ao,
+  _n as ap,
+  xr as aq,
+  ao as ar,
+  $o as as,
+  To as at,
+  Io as au,
+  go as av,
+  ho as aw,
+  fo as ax,
+  eo as ay,
+  Kr as az,
+  ms as b,
+  ds as c,
+  ko as d,
+  yt as e,
+  zt as f,
+  hs as g,
+  bo as h,
+  hn as i,
+  gr as j,
+  se as k,
+  Rr as l,
+  Ur as m,
+  zr as n,
+  so as o,
+  ro as p,
+  jr as q,
+  Lt as r,
+  gs as s,
+  Lr as t,
+  Gr as u,
+  to as v,
+  nn as w,
+  is as x,
+  Tn as y,
+  Bt as z
+};