@genai-fi/nanogpt 0.10.2 → 0.11.0

package/dist/zeros_like-BAz3iKru.js

@@ -0,0 +1,721 @@
+import { q as u, u as h, E as d, c9 as st, ca as rt, cb as nt, cc as et, cd as it, ce as pt, D as B, cf as at, cg as ht, b_ as ut, y as D, ch as ct, ci as ft, l as H, a3 as C, b$ as lt, cj as dt, ck as mt, cl as Dt, aG as yt, cm as It, a2 as wt, m as M, $ as F, cn as xt, co as gt, N as $, c3 as $t, cp as bt, cq as kt, cr as vt, cs as Nt, b as _t, ct as Tt, cu as Et, cv as St, cw as qt, cx as r, aZ as Kt, n as zt, a4 as W, cy as Pt, cz as Ct, p as Mt, o as Ot, b0 as At, c as Bt } from "./index-D0RBWjq8.js";
+import { e as j, a as R, l as G, b as X, d as V, m as Z, f as U, r as E, g as Ht, h as Ft, i as Wt, j as jt, k as Rt, n as Gt, o as Xt, c as Vt, p as Zt, q as Ut, t as Jt, u as Qt, v as Yt, w as Lt, x as to, y as oo, z as so, A as ro, B as no, C as eo, s as io, D as po, E as ao, F as ho } from "./unsorted_segment_sum-LAbmE9G4.js";
+import { r as l } from "./reshape-CkjKPPqB.js";
+import { b as uo } from "./broadcast_to-DDaNMbX7.js";
+import { c as co } from "./clip_by_value-Dn5tzexi.js";
+import { c as _ } from "./concat-C6X3AAlQ.js";
+import { w as J, n as Q, b as S, c as fo, g as lo, l as mo, a as Do, f as yo, d as Io, j as wo, m as xo, e as go, i as $o, h as bo, r as ko, s as vo, u as No } from "./resize_nearest_neighbor-DB8k9KN_.js";
+import { m as v } from "./mat_mul-DxpNTCRz.js";
+import { s as Y, k as _o, h as To, e as Eo, l as So, p as qo, r as Ko, a as zo } from "./step-dXR33iOg.js";
+import { e as Po, l as Co, a as Mo, m as Oo } from "./log_sum_exp-VLZgbFAH.js";
+import { e as Ao } from "./expand_dims-BzfJK2uc.js";
+import { f as Bo } from "./floor-DIb-lN_u.js";
+import { g as Ho } from "./gather-BcO5UQNJ.js";
+import { c as q } from "./complex-DClmWqJt.js";
+import { n as N, r as K, i as L, t as Fo } from "./transpose-JawVKyZy.js";
+import { s as T } from "./slice-Aqy7KbJh.js";
+import { m as Wo } from "./mod-PrOKlFxH.js";
+import { r as jo } from "./relu-Cf80uA2p.js";
+import { s as z } from "./split-BNz5jcGc.js";
+import { z as Ro } from "./zeros-DeiE2zTa.js";
+import { s as Go } from "./softmax-faLoUZVT.js";
+import { s as Xo } from "./squeeze--YMgaAAf.js";
+import { s as Vo } from "./stack-WJK22CFn.js";
+import { s as Zo } from "./sum-BdplSvq_.js";
+import { t as Uo } from "./tile-CvN_LyVr.js";
+function Jo(t) {
+  const s = { x: h(t, "x", "acos") };
+  return d.runKernel(st, s);
+}
+const Qo = /* @__PURE__ */ u({ acos_: Jo });
+function Yo(t) {
+  const s = { x: h(t, "x", "acosh") };
+  return d.runKernel(rt, s);
+}
+const Lo = /* @__PURE__ */ u({ acosh_: Yo });
+function ts(t, o = 0) {
+  const n = { x: h(t, "x", "argMin") }, e = { axis: o };
+  return d.runKernel(nt, n, e);
+}
+const os = /* @__PURE__ */ u({ argMin_: ts });
+function ss(t) {
+  const s = { x: h(t, "x", "asin") };
+  return d.runKernel(et, s);
+}
+const rs = /* @__PURE__ */ u({ asin_: ss });
+function ns(t) {
+  const s = { x: h(t, "x", "asinh") };
+  return d.runKernel(it, s);
+}
+const es = /* @__PURE__ */ u({ asinh_: ns });
+function is(t) {
+  const s = { x: h(t, "x", "atan") };
+  return d.runKernel(pt, s);
+}
+const ps = /* @__PURE__ */ u({ atan_: is });
+function as(t, o) {
+  let s = h(t, "a", "atan2"), n = h(o, "b", "atan2");
+  [s, n] = B(s, n);
+  const e = { a: s, b: n };
+  return d.runKernel(at, e);
+}
+const hs = /* @__PURE__ */ u({ atan2_: as });
+function us(t) {
+  const s = { x: h(t, "x", "atanh") };
+  return d.runKernel(ht, s);
+}
+const cs = /* @__PURE__ */ u({ atanh_: us });
+function fs(t) {
+  const s = { x: h(t, "x", "ceil", "float32") };
+  return d.runKernel(ut, s);
+}
+const ls = /* @__PURE__ */ u({ ceil_: fs });
+function ds(t, o, s = "NHWC") {
+  const n = h(t, "x", "depthToSpace", "float32"), e = s === "NHWC" ? n.shape[1] : n.shape[2], i = s === "NHWC" ? n.shape[2] : n.shape[3], p = s === "NHWC" ? n.shape[3] : n.shape[1];
+  D(o > 1, () => `blockSize should be > 1 for depthToSpace, but was: ${o}`), D(e * o >= 0, () => `Negative dimension size caused by overflow when multiplying
+    ${e} and ${o}  for depthToSpace with input shape
+    ${n.shape}`), D(i * o >= 0, () => `Negative dimension size caused by overflow when multiplying
+    ${i} and ${o} for depthToSpace with input shape
+        ${n.shape}`), D(p % (o * o) === 0, () => `Dimension size must be evenly divisible by ${o * o} but is ${p} for depthToSpace with input shape ${n.shape}`);
+  const a = { x: n }, f = { blockSize: o, dataFormat: s };
+  return d.runKernel(ct, a, f);
+}
+const ms = /* @__PURE__ */ u({ depthToSpace_: ds });
+function Ds(t, o, s, n, e = [1, 1], i = "NHWC") {
+  const p = h(t, "x", "dilation2d"), a = h(o, "filter", "dilation2d");
+  D(p.rank === 3 || p.rank === 4, () => `Error in dilation2d: input must be rank 3 or 4, but got rank ${p.rank}.`), D(a.rank === 3, () => `Error in dilation2d: filter must be rank 3, but got rank ${a.rank}.`), D(i === "NHWC", () => `Error in dilation2d: Only NHWC is currently supported, but got dataFormat of ${i}`);
+  let f = p, y = !1;
+  p.rank === 3 && (f = l(p, [1, p.shape[0], p.shape[1], p.shape[2]]), y = !0), D(f.shape[3] === a.shape[2], () => `Error in dilation2d:  input and filter must have the same depth: ${f.shape[3]} vs ${a.shape[2]}`);
+  const c = { x: f, filter: a }, m = { strides: s, pad: n, dilations: e }, I = d.runKernel(ft, c, m);
+  return y ? l(I, [I.shape[1], I.shape[2], I.shape[3]]) : I;
+}
+const ys = /* @__PURE__ */ u({ dilation2d_: Ds });
+function Is(t, o) {
+  let s = h(t, "a", "div"), n = h(o, "b", "div");
+  [s, n] = B(s, n);
+  const e = H(s, n), i = C(e), p = j(n, i);
+  return J(p, i, e);
+}
+const ws = /* @__PURE__ */ u({ divNoNan_: Is });
+function xs(t, o) {
+  const s = h(t, "t1", "dot"), n = h(o, "t2", "dot");
+  D((s.rank === 1 || s.rank === 2) && (n.rank === 1 || n.rank === 2), () => `Error in dot: inputs must all be rank 1 or 2, but got ranks ${s.rank} and ${n.rank}.`);
+  const e = s.rank === 1 ? s.size : s.shape[1], i = n.rank === 1 ? n.size : n.shape[0];
+  if (D(e === i, () => `Error in dot: inner dimensions of inputs must match, but got ${e} and ${i}.`), s.rank === 1 && n.rank === 1) {
+    const p = l(s, [1, -1]), a = l(n, [-1, 1]), f = v(p, a);
+    return l(f, []);
+  } else if (s.rank === 1 && n.rank === 2) {
+    const p = l(s, [1, -1]), a = l(n, [n.shape[0], n.shape[1]]), f = v(p, a);
+    return l(f, [f.size]);
+  } else if (s.rank === 2 && n.rank === 1) {
+    const p = l(n, [-1, 1]), a = v(s, p);
+    return l(a, [a.size]);
+  } else {
+    const p = l(n, [n.shape[0], n.shape[1]]);
+    return v(s, p);
+  }
+}
+const gs = /* @__PURE__ */ u({ dot_: xs });
+function $s(t, o = null, s = !1) {
+  return Q(t, "euclidean", o, s);
+}
+const bs = /* @__PURE__ */ u({ euclideanNorm_: $s });
+function ks(t) {
+  const s = { x: h(t, "x", "expm1") };
+  return d.runKernel(lt, s);
+}
+const vs = /* @__PURE__ */ u({ expm1_: ks });
+function Ns(t) {
+  const s = { x: h(t, "x", "isFinite") };
+  return d.runKernel(dt, s);
+}
+const _s = /* @__PURE__ */ u({ isFinite_: Ns });
+function Ts(t) {
+  const s = { x: h(t, "x", "isInf") };
+  return d.runKernel(mt, s);
+}
+const Es = /* @__PURE__ */ u({ isInf_: Ts });
+function Ss(t) {
+  const s = { x: h(t, "x", "isNaN") };
+  return d.runKernel(Dt, s);
+}
+const qs = /* @__PURE__ */ u({ isNaN_: Ss });
+function Ks(t, o = 5, s = 1, n = 1, e = 0.5) {
+  const i = h(t, "x", "localResponseNormalization");
+  D(i.rank === 4 || i.rank === 3, () => `Error in localResponseNormalization: x must be rank 3 or 4 but got
+               rank ${i.rank}.`), D(yt(o), () => `Error in localResponseNormalization: depthRadius must be an integer but got depthRadius ${o}.`);
+  let p = i, a = !1;
+  i.rank === 3 && (a = !0, p = l(i, [1, i.shape[0], i.shape[1], i.shape[2]]));
+  const f = { x: p }, y = { depthRadius: o, bias: s, alpha: n, beta: e }, c = d.runKernel(It, f, y);
+  return a ? l(c, [c.shape[1], c.shape[2], c.shape[3]]) : c;
+}
+const zs = /* @__PURE__ */ u({ localResponseNormalization_: Ks });
+function Ps(t) {
+  const o = h(t, "x", "logSigmoid");
+  return wt((n) => ({ value: N(R(N(n))), gradFunc: (p) => M(p, Y(N(n))) }))(o);
+}
+const Cs = /* @__PURE__ */ u({ logSigmoid_: Ps });
+function Ms(t, o) {
+  const s = h(t, "a", "logicalOr", "bool"), n = h(o, "b", "logicalOr", "bool");
+  F(s.shape, n.shape);
+  const e = { a: s, b: n };
+  return d.runKernel(xt, e);
+}
+const tt = /* @__PURE__ */ u({ logicalOr_: Ms });
+function Os(t, o) {
+  const s = h(t, "a", "logicalXor", "bool"), n = h(o, "b", "logicalXor", "bool");
+  return F(s.shape, n.shape), S(tt(t, o), G(S(t, o)));
+}
+const As = /* @__PURE__ */ u({ logicalXor_: Os });
+function Bs(t, o, s) {
+  D(s === "reflect" || s === "symmetric", () => `Invalid mode. Mode must be either reflect or symmetric. Got ${s}.`);
+  const n = h(t, "x", "mirrorPad");
+  if (n.rank === 0)
+    throw new Error("mirrorPad(scalar) is not defined. Pass non-scalar to mirrorPad");
+  D(o.length === n.rank, () => `Padding doesn't match input. Must be ${n.rank}. Got ${o.length}.`);
+  const e = s === "reflect" ? 1 : 0;
+  for (let a = 0; a < n.rank; a++)
+    D(o[a].length === 2, () => "Invalid number of paddings. Must be length of 2 each."), D(o[a][0] >= 0 && o[a][0] <= n.shape[a] - e && o[a][1] >= 0 && o[a][1] <= n.shape[a] - e, () => `Padding in dimension ${a} cannot be greater than or equal to ${n.shape[a] - e} or less than 0 for input of shape ${n.shape}`);
+  const i = { paddings: o, mode: s }, p = { x: n };
+  return d.runKernel(gt, p, i);
+}
+const Hs = /* @__PURE__ */ u({ mirrorPad_: Bs });
+function Fs(t, o, s, n, e, i, p) {
+  e == null && (e = [1, 1]), i == null && (i = 1), n === 0 && (n = "valid");
+  const a = h(t, "x", "maxPool");
+  let f = a, y = !1;
+  a.rank === 3 && (y = !0, f = l(a, [1, a.shape[0], a.shape[1], a.shape[2]])), D(_o(i, e), () => `Error in pool: Either strides or dilations must be 1. Got strides ${i} and dilations '${e}'`);
+  const c = To(f.shape, o, i, e, n), m = [c.dilationHeight, c.dilationWidth];
+  let I;
+  n === "same" ? I = js([c.filterHeight, c.filterWidth], m) : I = [[0, 0], [0, 0]];
+  const w = m[0] === 1 && m[1] === 1, [x, g] = Ws([c.inHeight, c.inWidth], m, I), b = w ? n : "valid", O = w ? f : X(f, m, x), A = (s === "avg" ? () => V(O, o, i, b, p) : () => Z(O, o, i, b, p))(), k = w ? A : U(A, m, g);
+  return y ? l(k, [k.shape[1], k.shape[2], k.shape[3]]) : k;
+}
+function Ws(t, o, s) {
+  const n = s.map((c) => c[0]), e = s.map((c) => c[1]), i = t.concat(n, e), p = o.map((c, m) => (c - i[m] % c) % c), a = e.map((c, m) => c + p[m]), f = o.map((c, m) => [n[m], a[m]]), y = o.map((c, m) => [0, p[m]]);
+  return [f, y];
+}
+function js(t, o) {
+  const n = t.map((p, a) => p + (p - 1) * (o[a] - 1)).map((p) => p - 1), e = n.map((p) => Math.floor(p / 2)), i = n.map((p, a) => p - e[a]);
+  return n.map((p, a) => [e[a], i[a]]);
+}
+const Rs = /* @__PURE__ */ u({ pool_: Fs });
+function Gs(t, o = null, s = !1) {
+  let n = h(t, "x", "prod");
+  n.dtype === "bool" && (n = $(n, "int32"));
+  const e = { x: n }, i = { axis: o, keepDims: s };
+  return d.runKernel($t, e, i);
+}
+const Xs = /* @__PURE__ */ u({ prod_: Gs });
+function Vs(t) {
+  const s = { x: h(t, "x", "reciprocal") };
+  return d.runKernel(bt, s);
+}
+const Zs = /* @__PURE__ */ u({ reciprocal_: Vs });
+function Us(t) {
+  const s = { x: h(t, "x", "sign") };
+  return d.runKernel(kt, s);
+}
+const Js = /* @__PURE__ */ u({ sign_: Us });
+function Qs(t) {
+  D(t.dtype === "complex64", () => `The dtype for tf.spectral.fft() must be complex64 but got ${t.dtype}.`);
+  const o = { input: t };
+  return d.runKernel(vt, o);
+}
+const ot = /* @__PURE__ */ u({ fft_: Qs });
+function Ys(t) {
+  D(t.dtype === "complex64", () => `The dtype for tf.spectral.ifft() must be complex64 but got ${t.dtype}.`);
+  const o = { input: t };
+  return d.runKernel(Nt, o);
+}
+const P = /* @__PURE__ */ u({ ifft_: Ys });
+function Ls(t) {
+  const o = t.shape[t.shape.length - 1], s = t.size / o;
+  let n;
+  if (o <= 2) {
+    const e = l(t, [s, o]);
+    n = P(e);
+  } else {
+    const e = [s, 2 * (o - 1)], i = l(K(t), [s, o]), p = l(L(t), [s, o]), a = E(T(i, [0, 1], [s, o - 2]), 1), f = M(E(T(p, [0, 1], [s, o - 2]), 1), _t(-1)), y = _([i, a], 1), c = _([p, f], 1), m = l(q(y, c), [e[0], e[1]]);
+    n = P(m);
+  }
+  if (n = K(n), t.rank === 3 && t.shape[0] !== 0) {
+    const e = n, i = t.shape[0];
+    n = l(n, [i, n.shape[0] / i, n.shape[1]]), e.dispose();
+  }
+  return n;
+}
+const tr = /* @__PURE__ */ u({ irfft_: Ls });
+function or(t, o) {
+  D(t.dtype === "float32", () => `The dtype for rfft() must be real value but got ${t.dtype}`);
+  let s = t.shape[t.shape.length - 1];
+  const n = t.size / s;
+  let e;
+  if (o != null && o < s) {
+    const x = t.shape.map((b) => 0), g = t.shape.map((b) => b);
+    g[t.shape.length - 1] = o, e = T(t, x, g), s = o;
+  } else if (o != null && o > s) {
+    const x = t.shape.map((g) => g);
+    x[t.shape.length - 1] = o - s, e = _([t, Ro(x)], t.shape.length - 1), s = o;
+  } else
+    e = t;
+  const i = C(e), p = l(q(e, i), [n, s]), a = ot(p), f = Math.floor(s / 2) + 1, y = K(a), c = L(a), m = z(y, [f, s - f], y.shape.length - 1), I = z(c, [f, s - f], c.shape.length - 1), w = e.shape.slice();
+  return w[e.shape.length - 1] = f, l(q(m[0], I[0]), w);
+}
+const sr = /* @__PURE__ */ u({ rfft_: or });
+function rr(t, o, s, n, e = 0, i = 0, p = 0, a = 0, f = 0) {
+  const c = { x: h(t, "x", "stridedSlice", "string_or_numeric") }, m = {
+    begin: o,
+    end: s,
+    strides: n,
+    beginMask: e,
+    endMask: i,
+    ellipsisMask: p,
+    newAxisMask: a,
+    shrinkAxisMask: f
+  };
+  return d.runKernel(Tt, c, m);
+}
+const nr = /* @__PURE__ */ u({ stridedSlice_: rr });
+function er(t) {
+  const s = { x: h(t, "x", "tan", "float32") };
+  return d.runKernel(Et, s);
+}
+const ir = /* @__PURE__ */ u({ tan_: er });
+function pr(t, o = 1, s = !0) {
+  const n = h(t, "x", "topk");
+  if (n.rank === 0)
+    throw new Error("topk() expects the input to be of rank 1 or higher");
+  const e = n.shape[n.shape.length - 1];
+  if (o < 0)
+    throw new Error(`'k' passed to topk() must be >= 0 but got ${o}`);
+  if (o > e)
+    throw new Error(`'k' passed to topk() must be <= the last dimension (${e}) but got ${o}`);
+  const i = { x: n }, p = { k: o, sorted: s }, [a, f] = d.runKernel(St, i, p);
+  return { values: a, indices: f };
+}
+const ar = /* @__PURE__ */ u({ topk_: pr });
+function hr(t, o = 0) {
+  const s = h(t, "x", "unique", "string_or_numeric");
+  D(s.rank > 0, () => "The input tensor must be at least 1D");
+  const n = { x: s }, e = { axis: o }, [i, p] = d.runKernel(qt, n, e);
+  return { values: i, indices: p };
+}
+const ur = /* @__PURE__ */ u({ unique_: hr });
+r().prototype.abs = function() {
+  return this.throwIfDisposed(), Kt(this);
+};
+r().prototype.acos = function() {
+  return this.throwIfDisposed(), Qo(this);
+};
+r().prototype.acosh = function() {
+  return this.throwIfDisposed(), Lo(this);
+};
+r().prototype.add = function(t) {
+  return this.throwIfDisposed(), zt(this, t);
+};
+r().prototype.all = function(t, o) {
+  return this.throwIfDisposed(), Ht(this, t, o);
+};
+r().prototype.any = function(t, o) {
+  return this.throwIfDisposed(), Ft(this, t, o);
+};
+r().prototype.argMax = function(t) {
+  return this.throwIfDisposed(), Wt(this, t);
+};
+r().prototype.argMin = function(t) {
+  return this.throwIfDisposed(), os(this, t);
+};
+r().prototype.asScalar = function() {
+  return this.throwIfDisposed(), D(this.size === 1, () => "The array must have only 1 element."), l(this, []);
+};
+r().prototype.asType = function(t) {
+  return this.throwIfDisposed(), $(this, t);
+};
+r().prototype.as1D = function() {
+  return this.throwIfDisposed(), l(this, [this.size]);
+};
+r().prototype.as2D = function(t, o) {
+  return this.throwIfDisposed(), l(this, [t, o]);
+};
+r().prototype.as3D = function(t, o, s) {
+  return this.throwIfDisposed(), l(this, [t, o, s]);
+};
+r().prototype.as4D = function(t, o, s, n) {
+  return this.throwIfDisposed(), l(this, [t, o, s, n]);
+};
+r().prototype.as5D = function(t, o, s, n, e) {
+  return this.throwIfDisposed(), l(this, [t, o, s, n, e]);
+};
+r().prototype.asin = function() {
+  return this.throwIfDisposed(), rs(this);
+};
+r().prototype.asinh = function() {
+  return this.throwIfDisposed(), es(this);
+};
+r().prototype.atan = function() {
+  return this.throwIfDisposed(), ps(this);
+};
+r().prototype.atan2 = function(t) {
+  return this.throwIfDisposed(), hs(this, t);
+};
+r().prototype.atanh = function() {
+  return this.throwIfDisposed(), cs(this);
+};
+r().prototype.avgPool = function(t, o, s, n) {
+  return this.throwIfDisposed(), V(this, t, o, s, n);
+};
+r().prototype.batchToSpaceND = function(t, o) {
+  return this.throwIfDisposed(), U(this, t, o);
+};
+r().prototype.batchNorm = function(t, o, s, n, e) {
+  return this.throwIfDisposed(), jt(this, t, o, s, n, e);
+};
+r().prototype.broadcastTo = function(t) {
+  return this.throwIfDisposed(), uo(this, t);
+};
+r().prototype.cast = function(t) {
+  return this.throwIfDisposed(), $(this, t);
+};
+r().prototype.ceil = function() {
+  return this.throwIfDisposed(), ls(this);
+};
+r().prototype.clipByValue = function(t, o) {
+  return this.throwIfDisposed(), co(this, t, o);
+};
+r().prototype.concat = function(t, o) {
+  return this.throwIfDisposed(), t instanceof W && (t = [t]), _([this, ...t], o);
+};
+r().prototype.conv1d = function(t, o, s, n, e, i) {
+  return this.throwIfDisposed(), Rt(this, t, o, s, n, e, i);
+};
+r().prototype.conv2dTranspose = function(t, o, s, n, e) {
+  return this.throwIfDisposed(), Gt(this, t, o, s, n, e);
+};
+r().prototype.conv2d = function(t, o, s, n, e, i) {
+  return this.throwIfDisposed(), Xt(this, t, o, s, n, e, i);
+};
+r().prototype.cos = function() {
+  return this.throwIfDisposed(), Vt(this);
+};
+r().prototype.cosh = function() {
+  return this.throwIfDisposed(), Zt(this);
+};
+r().prototype.cumprod = function(t, o, s) {
+  return this.throwIfDisposed(), Ut(this, t, o, s);
+};
+r().prototype.cumsum = function(t, o, s) {
+  return this.throwIfDisposed(), Jt(this, t, o, s);
+};
+r().prototype.depthToSpace = function(t, o) {
+  return this.throwIfDisposed(), ms(this, t, o);
+};
+r().prototype.depthwiseConv2d = function(t, o, s, n, e, i) {
+  return this.throwIfDisposed(), Qt(this, t, o, s, n, e, i);
+};
+r().prototype.dilation2d = function(t, o, s, n, e) {
+  return this.throwIfDisposed(), ys(this, t, o, s, n, e);
+};
+r().prototype.divNoNan = function(t) {
+  return this.throwIfDisposed(), ws(this, t);
+};
+r().prototype.div = function(t) {
+  return this.throwIfDisposed(), H(this, t);
+};
+r().prototype.dot = function(t) {
+  return this.throwIfDisposed(), gs(this, t);
+};
+r().prototype.elu = function() {
+  return this.throwIfDisposed(), Eo(this);
+};
+r().prototype.equal = function(t) {
+  return this.throwIfDisposed(), j(this, t);
+};
+r().prototype.erf = function() {
+  return this.throwIfDisposed(), Yt(this);
+};
+r().prototype.euclideanNorm = function(t, o) {
+  return this.throwIfDisposed(), bs(this, t, o);
+};
+r().prototype.exp = function() {
+  return this.throwIfDisposed(), Po(this);
+};
+r().prototype.expandDims = function(t) {
+  return this.throwIfDisposed(), Ao(this, t);
+};
+r().prototype.expm1 = function() {
+  return this.throwIfDisposed(), vs(this);
+};
+r().prototype.fft = function() {
+  return this.throwIfDisposed(), ot(this);
+};
+r().prototype.flatten = function() {
+  return this.throwIfDisposed(), l(this, [this.size]);
+};
+r().prototype.floor = function() {
+  return this.throwIfDisposed(), Bo(this);
+};
+r().prototype.floorDiv = function(t) {
+  return this.throwIfDisposed(), Pt(this, t);
+};
+r().prototype.gather = function(t, o, s) {
+  return this.throwIfDisposed(), Ho(this, t, o, s);
+};
+r().prototype.greaterEqual = function(t) {
+  return this.throwIfDisposed(), fo(this, t);
+};
+r().prototype.greater = function(t) {
+  return this.throwIfDisposed(), lo(this, t);
+};
+r().prototype.ifft = function() {
+  return this.throwIfDisposed(), P(this);
+};
+r().prototype.irfft = function() {
+  return this.throwIfDisposed(), tr(this);
+};
+r().prototype.isFinite = function() {
+  return this.throwIfDisposed(), _s(this);
+};
+r().prototype.isInf = function() {
+  return this.throwIfDisposed(), Es(this);
+};
+r().prototype.isNaN = function() {
+  return this.throwIfDisposed(), qs(this);
+};
+r().prototype.leakyRelu = function(t) {
+  return this.throwIfDisposed(), So(this, t);
+};
+r().prototype.lessEqual = function(t) {
+  return this.throwIfDisposed(), mo(this, t);
+};
+r().prototype.less = function(t) {
+  return this.throwIfDisposed(), Do(this, t);
+};
+r().prototype.localResponseNormalization = function(t, o, s, n) {
+  return this.throwIfDisposed(), zs(this, t, o, s, n);
+};
+r().prototype.logSigmoid = function() {
+  return this.throwIfDisposed(), Cs(this);
+};
+r().prototype.logSoftmax = function(t) {
+  return this.throwIfDisposed(), Lt(this, t);
+};
+r().prototype.logSumExp = function(t, o) {
+  return this.throwIfDisposed(), Co(this, t, o);
+};
+r().prototype.log = function() {
+  return this.throwIfDisposed(), Mo(this);
+};
+r().prototype.log1p = function() {
+  return this.throwIfDisposed(), yo(this);
+};
+r().prototype.logicalAnd = function(t) {
+  return this.throwIfDisposed(), S(this, t);
+};
+r().prototype.logicalNot = function() {
+  return this.throwIfDisposed(), G(this);
+};
+r().prototype.logicalOr = function(t) {
+  return this.throwIfDisposed(), tt(this, t);
+};
+r().prototype.logicalXor = function(t) {
+  return this.throwIfDisposed(), As(this, t);
+};
+r().prototype.matMul = function(t, o, s) {
+  return this.throwIfDisposed(), v(this, t, o, s);
+};
+r().prototype.maxPool = function(t, o, s, n) {
+  return this.throwIfDisposed(), Z(this, t, o, s, n);
+};
+r().prototype.max = function(t, o) {
+  return this.throwIfDisposed(), Oo(this, t, o);
+};
+r().prototype.maximum = function(t) {
+  return this.throwIfDisposed(), Ct(this, t);
+};
+r().prototype.mean = function(t, o) {
+  return this.throwIfDisposed(), Io(this, t, o);
+};
+r().prototype.min = function(t, o) {
+  return this.throwIfDisposed(), wo(this, t, o);
+};
+r().prototype.minimum = function(t) {
+  return this.throwIfDisposed(), xo(this, t);
+};
+r().prototype.mirrorPad = function(t, o) {
+  return this.throwIfDisposed(), Hs(this, t, o);
+};
+r().prototype.mod = function(t) {
+  return this.throwIfDisposed(), Wo(this, t);
+};
+r().prototype.mul = function(t) {
+  return this.throwIfDisposed(), M(this, t);
+};
+r().prototype.neg = function() {
+  return this.throwIfDisposed(), N(this);
+};
+r().prototype.norm = function(t, o, s) {
+  return this.throwIfDisposed(), Q(this, t, o, s);
+};
+r().prototype.notEqual = function(t) {
+  return this.throwIfDisposed(), go(this, t);
+};
+r().prototype.oneHot = function(t, o = 1, s = 0) {
+  return this.throwIfDisposed(), to(this, t, o, s);
+};
+r().prototype.onesLike = function() {
+  return this.throwIfDisposed(), oo(this);
+};
+r().prototype.pad = function(t, o) {
+  return this.throwIfDisposed(), so(this, t, o);
+};
+r().prototype.pool = function(t, o, s, n, e, i) {
+  return this.throwIfDisposed(), Rs(this, t, o, s, n, e, i);
+};
+r().prototype.pow = function(t) {
+  return this.throwIfDisposed(), Mt(this, t);
+};
+r().prototype.prelu = function(t) {
+  return this.throwIfDisposed(), qo(this, t);
+};
+r().prototype.prod = function(t, o) {
+  return this.throwIfDisposed(), Xs(this, t, o);
+};
+r().prototype.reciprocal = function() {
+  return this.throwIfDisposed(), Zs(this);
+};
+r().prototype.relu = function() {
+  return this.throwIfDisposed(), jo(this);
+};
+r().prototype.relu6 = function() {
+  return this.throwIfDisposed(), Ko(this);
+};
+r().prototype.reshapeAs = function(t) {
+  return this.throwIfDisposed(), l(this, t.shape);
+};
+r().prototype.reshape = function(t) {
+  return this.throwIfDisposed(), l(this, t);
+};
+r().prototype.resizeBilinear = function(t, o, s) {
+  return this.throwIfDisposed(), $o(this, t, o, s);
+};
+r().prototype.resizeNearestNeighbor = function(t, o, s) {
+  return this.throwIfDisposed(), bo(this, t, o, s);
+};
+r().prototype.reverse = function(t) {
+  return this.throwIfDisposed(), E(this, t);
+};
+r().prototype.rfft = function() {
+  return this.throwIfDisposed(), sr(this);
+};
+r().prototype.round = function() {
+  return this.throwIfDisposed(), ko(this);
+};
+r().prototype.rsqrt = function() {
+  return this.throwIfDisposed(), ro(this);
+};
+r().prototype.selu = function() {
+  return this.throwIfDisposed(), no(this);
+};
+r().prototype.separableConv2d = function(t, o, s, n, e, i) {
+  return this.throwIfDisposed(), eo(this, t, o, s, n, e, i);
+};
+r().prototype.sigmoid = function() {
+  return this.throwIfDisposed(), Y(this);
+};
+r().prototype.sign = function() {
+  return this.throwIfDisposed(), Js(this);
+};
+r().prototype.sin = function() {
+  return this.throwIfDisposed(), io(this);
+};
+r().prototype.sinh = function() {
+  return this.throwIfDisposed(), po(this);
+};
+r().prototype.slice = function(t, o) {
+  return this.throwIfDisposed(), T(this, t, o);
+};
+r().prototype.softmax = function(t) {
+  return this.throwIfDisposed(), Go(this, t);
+};
+r().prototype.softplus = function() {
+  return this.throwIfDisposed(), R(this);
+};
+r().prototype.spaceToBatchND = function(t, o) {
+  return this.throwIfDisposed(), X(this, t, o);
+};
+r().prototype.split = function(t, o) {
+  return this.throwIfDisposed(), z(this, t, o);
+};
+r().prototype.sqrt = function() {
+  return this.throwIfDisposed(), Ot(this);
+};
+r().prototype.square = function() {
+  return this.throwIfDisposed(), At(this);
+};
+r().prototype.squaredDifference = function(t) {
+  return this.throwIfDisposed(), vo(this, t);
+};
+r().prototype.squeeze = function(t) {
+  return this.throwIfDisposed(), Xo(this, t);
+};
+r().prototype.stack = function(t, o) {
+  this.throwIfDisposed();
+  const s = t instanceof W ? [this, t] : [this, ...t];
+  return Vo(s, o);
+};
+r().prototype.step = function(t) {
+  return this.throwIfDisposed(), zo(this, t);
+};
+r().prototype.stridedSlice = function(t, o, s, n, e, i, p, a) {
+  return this.throwIfDisposed(), nr(this, t, o, s, n, e, i, p, a);
+};
+r().prototype.sub = function(t) {
+  return this.throwIfDisposed(), Bt(this, t);
+};
+r().prototype.sum = function(t, o) {
+  return this.throwIfDisposed(), Zo(this, t, o);
+};
+r().prototype.tan = function() {
+  return this.throwIfDisposed(), ir(this);
+};
+r().prototype.tanh = function() {
+  return this.throwIfDisposed(), ao(this);
+};
+r().prototype.tile = function(t) {
+  return this.throwIfDisposed(), Uo(this, t);
+};
+r().prototype.toBool = function() {
+  return this.throwIfDisposed(), $(this, "bool");
+};
+r().prototype.toFloat = function() {
+  return this.throwIfDisposed(), $(this, "float32");
+};
+r().prototype.toInt = function() {
+  return this.throwIfDisposed(), $(this, "int32");
+};
+r().prototype.topk = function(t, o) {
+  return this.throwIfDisposed(), ar(this, t, o);
+};
+r().prototype.transpose = function(t) {
+  return this.throwIfDisposed(), Fo(this, t);
+};
+r().prototype.unique = function(t) {
+  return this.throwIfDisposed(), ur(this, t);
+};
+r().prototype.unsortedSegmentSum = function(t, o) {
+  return this.throwIfDisposed(), ho(this, t, o);
+};
+r().prototype.unstack = function(t) {
+  return this.throwIfDisposed(), No(this, t);
+};
+r().prototype.where = function(t, o) {
+  return this.throwIfDisposed(), J(t, this, o);
+};
+r().prototype.zerosLike = function() {
+  return this.throwIfDisposed(), C(this);
+};
+export {
+  Zs as r,
+  ar as t
+};