@genai-fi/nanogpt 0.20.0 → 0.20.2

package/dist/shared-D1coEFea.js

@@ -0,0 +1,1314 @@
+import { r as e } from "./chunk-BPntVaq0.js";
+import { $o as t, $s as n, Ao as r, Bs as i, Ci as a, Di as o, Dn as s, En as c, Es as l, Fa as u, Fo as d, Hs as f, In as p, Jo as m, Ka as h, Ln as g, Na as _, Ni as v, Pi as y, Ps as b, Ra as x, Rs as S, Ti as C, Tn as ee, Us as w, Vs as T, Xr as E, Xs as D, Ya as te, _o as ne, aa as re, bo as ie, br as ae, ca as oe, di as se, fs as ce, ho as le, hs as ue, ki as O, ms as de, na as fe, nc as pe, no as me, ns as he, oa as ge, oc as k, qa as _e, ro as ve, sr as ye, uc as A, wn as be, wo as j, za as M } from "./dist-BewPQWjc.js";
+import { B as xe, H as Se, R as Ce, V as we, _ as Te, c as N, d as Ee, f as De, g as Oe, h as ke, l as Ae, m as je, n as Me, p as Ne, r as P, s as Pe, u as Fe, v as Ie, z as Le } from "./backend_util-Cg-roD1p.js";
+import { a as Re, i as ze, n as Be, t as Ve } from "./slice_util-Dgb3ANWI.js";
+import { s as F } from "./complex_util-CkazZsaH.js";
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/cpu_util.js
+function I(e, t) {
+	Array.isArray(e) || (e = [e]), e.forEach((e) => {
+		e != null && b(e.dtype !== "complex64", () => `${t} does not support complex64 tensors in the CPU backend.`);
+	});
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Abs.js
+function He(e) {
+	let t = new Float32Array(e.length);
+	for (let n = 0; n < e.length; ++n) t[n] = Math.abs(e[n]);
+	return t;
+}
+var Ue = {
+	kernelName: "Abs",
+	backendName: "cpu",
+	kernelFunc: (e) => {
+		let { x: t } = e.inputs, n = e.backend;
+		I(t, "abs");
+		let r = new Float32Array(k(t.shape)), i = n.data.get(t.dataId).values;
+		return r = He(i), n.makeOutput(r, t.shape, t.dtype);
+	}
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/utils/binary_impl.js
+function L(e) {
+	return (t, n, r, i, a) => {
+		let o = p(t, n), s = o.length, c = S(o), l = T(a, k(o)), u = t.length, d = n.length, f = S(t), m = S(n), h = g(t, o), _ = g(n, o);
+		if (h.length + _.length === 0) for (let t = 0; t < l.length; ++t) l[t] = e(r[t % r.length], i[t % i.length]);
+		else for (let t = 0; t < l.length; ++t) {
+			let n = w(t, s, c), a = n.slice(-u);
+			h.forEach((e) => a[e] = 0);
+			let o = D(a, u, f), p = n.slice(-d);
+			_.forEach((e) => p[e] = 0);
+			let g = D(p, d, m);
+			l[t] = e(r[o], i[g]);
+		}
+		return [l, o];
+	};
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Complex.js
+function R(e) {
+	let { inputs: t, backend: n } = e, { real: r, imag: i } = t, a = n.data.get(r.dataId).values, o = n.data.get(i.dataId).values, s = n.makeTensorInfo(r.shape, "complex64"), c = n.data.get(s.dataId);
+	return c.complexTensorInfos = {
+		real: n.makeTensorInfo(r.shape, "float32", a),
+		imag: n.makeTensorInfo(i.shape, "float32", o)
+	}, s;
+}
+var We = {
+	kernelName: oe,
+	backendName: "cpu",
+	kernelFunc: R
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/utils/zeros_impl.js
+function z(e, t, r = "float32") {
+	if (r === "complex64") return R({
+		inputs: {
+			real: z(e, t, "float32"),
+			imag: z(e, t, "float32")
+		},
+		backend: e
+	});
+	let i = n(k(t), r);
+	return e.makeTensorInfo(t, r, i);
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Identity.js
+function B(e) {
+	let { inputs: t, backend: n } = e, { x: r } = t;
+	return n.incRef(r.dataId), {
+		dataId: r.dataId,
+		shape: r.shape,
+		dtype: r.dtype
+	};
+}
+var Ge = {
+	kernelName: te,
+	backendName: "cpu",
+	kernelFunc: B
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Real.js
+function V(e) {
+	let { inputs: t, backend: n } = e, { input: r } = t, i = n.data.get(r.dataId).complexTensorInfos.real, a = n.data.get(i.dataId).values;
+	return n.makeTensorInfo(i.shape, i.dtype, a);
+}
+var Ke = {
+	kernelName: d,
+	backendName: "cpu",
+	kernelFunc: V
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Cast.js
+function qe(e, t, n, r) {
+	if (r === "int32") return [
+		t,
+		"int32",
+		Int32Array.from(e)
+	];
+	if (r === "bool") {
+		let r = v([0], n), [i, a] = L((e, t) => e === t ? 0 : 1)(t, [], e, r, "bool");
+		return [
+			a,
+			"bool",
+			i
+		];
+	}
+	throw Error(`Error in Cast: failed to cast ${n} to ${r}`);
+}
+function H(e) {
+	let { inputs: t, backend: n, attrs: r } = e, { x: i } = t, { dtype: a } = r;
+	if (a === "complex64") {
+		if (i.dtype === "complex64") return B({
+			inputs: { x: i },
+			backend: n
+		});
+		let e = z(n, i.shape, i.dtype), t = H({
+			inputs: { x: i },
+			backend: n,
+			attrs: { dtype: "float32" }
+		}), r = R({
+			inputs: {
+				real: t,
+				imag: e
+			},
+			backend: n
+		});
+		return n.disposeIntermediateTensorInfo(e), n.disposeIntermediateTensorInfo(t), r;
+	}
+	if (i.dtype === "complex64") {
+		let e = V({
+			inputs: { input: i },
+			backend: n
+		}), t = H({
+			inputs: { x: e },
+			backend: n,
+			attrs: { dtype: a }
+		});
+		return n.disposeIntermediateTensorInfo(e), t;
+	}
+	if (!f(i.dtype, a)) {
+		let e = B({
+			inputs: { x: i },
+			backend: n
+		});
+		return {
+			dataId: e.dataId,
+			shape: e.shape,
+			dtype: a
+		};
+	}
+	let o = n.data.get(i.dataId).values, [s, c, l] = qe(o, i.shape, i.dtype, a);
+	return n.makeTensorInfo(s, c, l);
+}
+var Je = {
+	kernelName: re,
+	backendName: "cpu",
+	kernelFunc: H
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/utils/binary_utils.js
+function U(e, t, n, r) {
+	return n == null ? ({ inputs: n, backend: i }) => {
+		let { a, b: o } = n, s = i;
+		I([a, o], e);
+		let c = s.data.get(a.dataId).values, l = s.data.get(o.dataId).values, u = a.dtype === "string" ? P(c) : c, d = a.dtype === "string" ? P(l) : l, f = r || a.dtype, [p, m] = t(a.shape, o.shape, u, d, f);
+		return s.makeTensorInfo(m, f, p);
+	} : ({ inputs: e, backend: i }) => {
+		let { a, b: o } = e, s = i;
+		if (a.dtype === "complex64" || o.dtype === "complex64") {
+			let e = H({
+				inputs: { x: a },
+				backend: s,
+				attrs: { dtype: "complex64" }
+			}), t = s.data.get(e.dataId), r = t.complexTensorInfos.real, i = t.complexTensorInfos.imag, c = s.data.get(r.dataId).values, l = s.data.get(i.dataId).values, u = H({
+				inputs: { x: o },
+				backend: s,
+				attrs: { dtype: "complex64" }
+			}), d = s.data.get(u.dataId), f = d.complexTensorInfos.real, p = d.complexTensorInfos.imag, m = s.data.get(f.dataId).values, h = s.data.get(p.dataId).values, [g, _, v] = n(a.shape, o.shape, c, l, m, h), y = s.makeTensorInfo(v, "float32", g), b = s.makeTensorInfo(v, "float32", _), x = R({
+				inputs: {
+					real: y,
+					imag: b
+				},
+				backend: s
+			});
+			return s.disposeIntermediateTensorInfo(e), s.disposeIntermediateTensorInfo(u), s.disposeIntermediateTensorInfo(y), s.disposeIntermediateTensorInfo(b), x;
+		} else {
+			let e = s.data.get(a.dataId).values, n = s.data.get(o.dataId).values, i = r || a.dtype, [c, l] = t(a.shape, o.shape, e, n, i);
+			return s.makeTensorInfo(l, i, c);
+		}
+	};
+}
+function W(e) {
+	return (t, n, r, i, a, o) => {
+		let s = p(t, n), c = k(s), l = s.length, u = S(s), d = T("float32", c), f = T("float32", c), m = g(t, s), h = g(n, s), _ = F(r, i), v = F(a, o), y = t.length, b = S(t), x = n.length, C = S(n);
+		if (m.length + h.length === 0) for (let t = 0; t < d.length; t++) {
+			let n = t % _.length, r = t % v.length, i = e(_[n * 2], _[n * 2 + 1], v[r * 2], v[r * 2 + 1]);
+			d[t] = i.real, f[t] = i.imag;
+		}
+		else for (let t = 0; t < d.length; t++) {
+			let n = w(t, l, u), r = n.slice(-y);
+			m.forEach((e) => r[e] = 0);
+			let i = D(r, y, b), a = n.slice(-x);
+			h.forEach((e) => a[e] = 0);
+			let o = D(a, x, C), s = e(_[i * 2], _[i * 2 + 1], v[o * 2], v[o * 2 + 1]);
+			d[t] = s.real, f[t] = s.imag;
+		}
+		return [
+			d,
+			f,
+			s
+		];
+	};
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Add.js
+var Ye = L(((e, t) => e + t)), Xe = U("Add", Ye, W(((e, t, n, r) => ({
+	real: e + n,
+	imag: t + r
+})))), Ze = {
+	kernelName: "Add",
+	backendName: "cpu",
+	kernelFunc: Xe
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Bincount_impl.js
+function Qe(e, t, r, i, a) {
+	let o = k(i), s = n(a, r);
+	for (let n = 0; n < e.length; n++) {
+		let r = e[n];
+		if (r < 0) throw Error("Input x must be non-negative!");
+		r >= a || (o > 0 ? s[r] += t[n] : s[r] += 1);
+	}
+	return s;
+}
+function $e(e, t, n, r = !1) {
+	let i = e.shape[0], a = e.shape[1], o = E([i, n], t.dtype);
+	for (let s = 0; s < i; s++) for (let i = 0; i < a; i++) {
+		let a = e.get(s, i);
+		if (a < 0) throw Error("Input x must be non-negative!");
+		a >= n || (r ? o.set(1, s, a) : t.size > 0 ? o.set(o.get(s, a) + t.get(s, i), s, a) : o.set(o.get(s, a) + 1, s, a));
+	}
+	return o;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/BitwiseAnd.js
+var et = L(((e, t) => e & t)), tt = {
+	kernelName: fe,
+	backendName: "cpu",
+	kernelFunc: U(fe, et)
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/utils/unary_impl.js
+function G(e) {
+	return (t, n, r) => {
+		let a = i(n, t.length);
+		for (let n = 0; n < t.length; ++n) a[n] = e(t[n], r);
+		return a;
+	};
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/utils/unary_utils.js
+function K(e, t, n) {
+	return q(e, G(t), n);
+}
+function q(e, t, n) {
+	return ({ inputs: r, attrs: i, backend: a }) => {
+		let { x: o } = r;
+		I(o, e);
+		let s = a, c = s.data.get(o.dataId).values, l;
+		if (o.dtype === "string") {
+			if (!Array.isArray(c)) throw Error("String tensor's value was not an instance of Array");
+			l = P(c);
+		} else l = c;
+		let u = n || o.dtype, d = t(l, u, i);
+		return s.makeTensorInfo(o.shape, u, d);
+	};
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Ceil.js
+var nt = G((e) => Math.ceil(e)), rt = {
+	kernelName: ge,
+	backendName: "cpu",
+	kernelFunc: q(ge, nt)
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Concat_impl.js
+function it(e, t, n, r) {
+	let a = i(n, k(t));
+	if (r && n !== "string") {
+		let t = 0;
+		e.forEach((e) => {
+			let n = k(e.shape);
+			a.set(e.vals, t), t += n;
+		});
+	} else {
+		let r = 0;
+		e.forEach((e) => {
+			let i = n === "string" ? P(e.vals) : e.vals, o = 0;
+			for (let n = 0; n < e.shape[0]; ++n) {
+				let s = n * t[1] + r;
+				for (let t = 0; t < e.shape[1]; ++t) a[s + t] = i[o++];
+			}
+			r += e.shape[1];
+		});
+	}
+	return a;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Equal.js
+var at = L((e, t) => +(e === t)), ot = U(_, at, null, "bool"), st = {
+	kernelName: _,
+	backendName: "cpu",
+	kernelFunc: ot
+}, ct = G((e) => Math.exp(e)), lt = q("Exp", ct, "float32"), ut = {
+	kernelName: "Exp",
+	backendName: "cpu",
+	kernelFunc: lt
+}, dt = G((e) => Math.expm1(e)), ft = {
+	kernelName: u,
+	backendName: "cpu",
+	kernelFunc: q(u, dt)
+}, pt = G((e) => Math.floor(e)), mt = {
+	kernelName: x,
+	backendName: "cpu",
+	kernelFunc: q(x, pt)
+}, ht = L((e, t) => Math.floor(e / t)), gt = {
+	kernelName: M,
+	backendName: "cpu",
+	kernelFunc: U(M, ht, null, "int32")
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/GatherNd_Impl.js
+function _t(e, t, n, r, i, a, o, s, c) {
+	let l = E([r, a], n);
+	for (let n = 0; n < r; n++) {
+		let r = [], u = 0;
+		for (let t = 0; t < i; t++) {
+			let a = e[n * i + t];
+			u += a * o[t], r.push(a);
+		}
+		if (u < 0 || u >= c / a) throw Error(`Invalid indices: ${r} does not index into ${s}`);
+		for (let e = 0; e < a; e++) l.values[n * a + e] = t.get(...t.indexToLoc(u * a + e));
+	}
+	return l;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/GatherV2_impl.js
+function vt(e, t, n) {
+	let r = E(n, e.dtype);
+	for (let n = 0; n < r.size; ++n) {
+		let i = r.indexToLoc(n).slice(), a = i[0], o = i[2], s = t.locToIndex([a, o]);
+		i[2] = t.values[s];
+		let c = e.locToIndex(i);
+		0 <= c && c < e.values.length && (r.values[n] = e.values[c]);
+	}
+	return r;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Greater.js
+var yt = L((e, t) => +(e > t)), bt = {
+	kernelName: h,
+	backendName: "cpu",
+	kernelFunc: U(h, yt, null, "bool")
+}, xt = L((e, t) => +(e >= t)), St = {
+	kernelName: _e,
+	backendName: "cpu",
+	kernelFunc: U(_e, xt, null, "bool")
+}, Ct = L((e, t) => +(e < t)), wt = {
+	kernelName: me,
+	backendName: "cpu",
+	kernelFunc: U(me, Ct, null, "bool")
+}, Tt = L((e, t) => +(e <= t)), Et = {
+	kernelName: ve,
+	backendName: "cpu",
+	kernelFunc: U(ve, Tt, null, "bool")
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/LinSpace_impl.js
+function Dt(e, t, r) {
+	let i = (t - e) / (r - 1), a = n(r, "float32");
+	a[0] = e;
+	for (let e = 1; e < a.length; e++) a[e] = a[e - 1] + i;
+	return a;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Log.js
+var Ot = G((e) => Math.log(e)), kt = {
+	kernelName: "Log",
+	backendName: "cpu",
+	kernelFunc: q("Log", Ot)
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Max_impl.js
+function At(e, t, n, r) {
+	let i = T(r, k(n));
+	for (let n = 0; n < i.length; ++n) {
+		let r = n * t, a = e[r];
+		for (let n = 0; n < t; ++n) {
+			let t = e[r + n];
+			(Number.isNaN(t) || t > a) && (a = t);
+		}
+		i[n] = a;
+	}
+	return i;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Maximum.js
+var jt = L(((e, t) => Math.max(e, t))), Mt = {
+	kernelName: le,
+	backendName: "cpu",
+	kernelFunc: U(le, jt)
+}, Nt = L(((e, t) => Math.min(e, t))), Pt = {
+	kernelName: ne,
+	backendName: "cpu",
+	kernelFunc: U(ne, Nt)
+}, J = L(((e, t) => e * t)), Ft = U(ie, J, W(((e, t, n, r) => ({
+	real: e * n - t * r,
+	imag: e * r + t * n
+})))), It = {
+	kernelName: ie,
+	backendName: "cpu",
+	kernelFunc: Ft
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Neg.js
+function Lt(e, t, n) {
+	return J([], t, o(-1, n), e, n);
+}
+function Rt(e) {
+	let { inputs: t, backend: n } = e, { x: r } = t;
+	I(r, "neg");
+	let i = n.data.get(r.dataId).values, [a, o] = Lt(i, r.shape, r.dtype);
+	return n.makeTensorInfo(o, r.dtype, a);
+}
+var zt = {
+	kernelName: "Neg",
+	backendName: "cpu",
+	kernelFunc: Rt
+}, Bt = L(((e, t) => e === t ? 0 : 1)), Vt = {
+	kernelName: j,
+	backendName: "cpu",
+	kernelFunc: U(j, Bt, null, "bool")
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Transpose_impl.js
+function Y(e, t, n, r, i) {
+	let a = t.length, o = k(t), s = S(t), c = S(i), l = T(n, k(i));
+	for (let t = 0; t < o; ++t) {
+		let n = w(t, a, s), i = Array(n.length);
+		for (let e = 0; e < i.length; e++) i[e] = n[r[e]];
+		let o = D(i, a, c);
+		l[o] = e[t];
+	}
+	return l;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Transpose.js
+function X(e) {
+	let { inputs: t, attrs: n, backend: r } = e, { x: i } = t, { perm: a } = n;
+	I(i, "transpose");
+	let o = i.shape.length, s = Array(o);
+	for (let e = 0; e < s.length; e++) s[e] = i.shape[a[e]];
+	let c = r.data.get(i.dataId).values, l = Y(c, i.shape, i.dtype, a, s);
+	return {
+		dataId: r.write(l, s, i.dtype),
+		shape: s,
+		dtype: i.dtype
+	};
+}
+var Ht = {
+	kernelName: l,
+	backendName: "cpu",
+	kernelFunc: X
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Prod.js
+function Ut(e, t, r, i) {
+	let [o, s] = be(e, i), c = a(t, "int32"), l = n(k(o), c), u = k(s);
+	for (let e = 0; e < l.length; ++e) {
+		let t = e * u, n = 1;
+		for (let e = 0; e < u; ++e) n *= r[t + e];
+		l[e] = n;
+	}
+	return {
+		outVals: l,
+		outShape: o,
+		outDtype: c
+	};
+}
+function Wt(e) {
+	let { inputs: t, backend: n, attrs: r } = e, { x: i } = t, { axis: a, keepDims: o } = r;
+	I(i, "prod");
+	let l = i.shape.length, u = pe(a, i.shape), d = c(u, l), f = u, p = i, m = [];
+	d != null && (p = X({
+		inputs: { x: i },
+		backend: n,
+		attrs: { perm: d }
+	}), m.push(p), f = s(f.length, l));
+	let h = n.data.get(p.dataId).values, { outVals: g, outShape: _, outDtype: v } = Ut(p.shape, p.dtype, h, f), y = _;
+	return o && (y = ee(_, u)), m.forEach((e) => n.disposeIntermediateTensorInfo(e)), n.makeTensorInfo(y, v, g);
+}
+var Gt = {
+	kernelName: r,
+	backendName: "cpu",
+	kernelFunc: Wt
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/RaggedGather_impl.js
+function Kt(e, t, n) {
+	e.forEach((e, r) => {
+		if (e < 0 || e >= n) {
+			let i = w(r, t.length, S(t)).join(",");
+			throw Error(`indices[${i}] = ${e} is not in [0, ${n})`);
+		}
+	});
+}
+function qt(e, t) {
+	for (let n = 0; n < e.length; ++n) {
+		let r = e[n], i = n === e.length - 1 ? t : e[n + 1].length;
+		if (r.length === 0) throw Error("Ragged splits may not be empty");
+		if (r[0] < 0) throw Error("Ragged splits must be non-negative");
+		if (r[r.length - 1] > i) throw Error("Ragged splits must not point past values");
+		for (let e = 1; e < r.length; ++e) if (r[e - 1] > r[e]) throw Error("Ragged splits must be sorted in ascending order");
+	}
+}
+function Jt(e, t, n, r) {
+	let i = [], a = 0, o = t.length - 1 + n.length, s = Array(o).fill(null).map(() => [0]);
+	qt(n, r);
+	let c = 1;
+	for (let e = 0; e < t.length - 1; ++e) {
+		c *= t[e];
+		let n = t[e + 1];
+		for (let t = 1; t < c + 1; ++t) s[e].push(t * n);
+	}
+	for (let r = 0; r < e.length; ++r) {
+		let o = e[r], c = e[r] + 1;
+		for (let e = 0; e < n.length; ++e) {
+			let r = n[e], i = e + t.length - 1;
+			if (i >= 0) {
+				let e = s[i], t = e[e.length - 1] - r[o];
+				for (let e = o; e < c; ++e) s[i].push(r[e + 1] + t);
+			}
+			o = r[o], c = r[c];
+		}
+		c !== o && (i.push([o, c]), a += c - o);
+	}
+	return {
+		outSplits: s,
+		valueSlices: i,
+		numValues: a
+	};
+}
+function Yt(e) {
+	let t = [];
+	for (let n = 0; n < e.length; ++n) {
+		let r = e[n].length, a = i("int32", r);
+		t.push(a), e[n].forEach((e, t) => a[t] = e);
+	}
+	return t;
+}
+function Xt(e, t) {
+	let n = e.slice(0, t);
+	for (; n.length < t;) n.push(1);
+	for (let r = t; r < e.length; r++) n[t - 1] *= e[r];
+	return n;
+}
+function Zt(e, t, n, r, i, a) {
+	let o = Xt(t, 2)[1], s = Xt(a, 2)[1], c = 0;
+	for (let t of n) for (let n = t[0]; n < t[1]; ++n) {
+		for (let t = 0; t < r; ++t) i[c * s + t] = e[n * o + t];
+		++c;
+	}
+}
+function Qt(e, t, n, r, a) {
+	let o = t.slice();
+	o[0] = a;
+	let s = i(n, k(o)), c = e.length;
+	return Zt(e, t, r, c === 0 ? 0 : c / t[0], s, o), [s, o];
+}
+function $t(e, t, n, r, i, a, o, s) {
+	if (e.length === 0) throw Error("paramsNestedSplits must be non empty");
+	if (t[0].length === 0) throw Error("Split tensors must not be scalars");
+	if (Kt(a, o, t[0][0] - 1), r.length === 0) throw Error("params.rank must be nonzero");
+	let c = r[0], { outSplits: l, valueSlices: u, numValues: d } = Jt(a, o, e, c), f = Yt(l), p = Qt(n, r, i, u, d);
+	return [
+		f,
+		p[0],
+		p[1]
+	];
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/RaggedRange_impl.js
+var en = 2147483647;
+function tn(e, t, n, r, a, o, s) {
+	if (t.length > 1) throw Error("starts must be a scalar or vector");
+	if (a.length > 1) throw Error("limits must be a scalar or vector");
+	if (s.length > 1) throw Error("deltas must be a scalar or vector");
+	let c = t.length === 0, l = a.length === 0, u = s.length === 0, d = [];
+	c || d.push(t[0]), l || d.push(a[0]), u || d.push(s[0]);
+	for (let e = 1; e < d.length; ++e) if (d[e] !== d[e - 1]) throw Error("starts, limits, and deltas must have the same shape");
+	let f = d.length === 0 ? 1 : d[0], p = i("int32", f + 1);
+	p[0] = 0;
+	for (let t = 0; t < f; ++t) {
+		let n = c ? e[0] : e[t], i = l ? r[0] : r[t], a = u ? o[0] : o[t];
+		if (a === 0) throw Error("Requires delta != 0");
+		let s;
+		if (a > 0 && i < n || a < 0 && i > n) s = 0;
+		else if (s = Math.ceil(Math.abs((i - n) / a)), s > en) throw Error(`Requires ((limit - start) / delta) <= ${en}`);
+		p[t + 1] = p[t] + s;
+	}
+	let m = p[f], h = i(n, m), g = 0;
+	for (let t = 0; t < f; ++t) {
+		let n = p[t + 1] - p[t], r = c ? e[0] : e[t], i = u ? o[0] : o[t];
+		for (let e = 0; e < n; ++e) h[g++] = r, r += i;
+	}
+	return [p, h];
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/RaggedTensorToTensor_impl.js
+var Z = Ce, nn = class e {
+	constructor(e, t, n, r, i, a, o, s, c, l) {
+		this.shape = e, this.shapeShape = t, this.values = n, this.valuesShape = r, this.valuesDType = i, this.defaultValue = a, this.defaultValueShape = o, this.rowPartitionValues = s, this.rowPartitionValuesShapes = c, this.rowPartitionTypes = we(l), this.raggedRank = xe(this.rowPartitionTypes);
+	}
+	getRowPartitionTypeByDimension(e) {
+		return this.rowPartitionTypes[0] === Z.FIRST_DIM_SIZE ? this.rowPartitionTypes[e + 1] : this.rowPartitionTypes[e];
+	}
+	getRowPartitionTensor(e) {
+		return this.rowPartitionTypes[0] === Z.FIRST_DIM_SIZE ? this.rowPartitionValues[e + 1] : this.rowPartitionValues[e];
+	}
+	getMaxWidth(t) {
+		let n = this.getRowPartitionTensor(t - 1);
+		switch (this.getRowPartitionTypeByDimension(t - 1)) {
+			case Z.VALUE_ROWIDS: return e.getMaxWidthValueRowID(n);
+			case Z.ROW_SPLITS: return e.getMaxWidthRowSplit(n);
+			default: throw Error(`Cannot handle partition type ${Z[this.getRowPartitionTypeByDimension(t - 1)]}`);
+		}
+	}
+	static getMaxWidthRowSplit(e) {
+		let t = e.length;
+		if (t === 0 || t === 1) return 0;
+		let n = 0;
+		for (let r = 0; r < t - 1; ++r) {
+			let t = e[r + 1] - e[r];
+			t > n && (n = t);
+		}
+		return n;
+	}
+	static getMaxWidthValueRowID(e) {
+		let t = e.length;
+		if (t === 0) return 0;
+		let n = 0, r = e[0], i = 0;
+		for (let a = 1; a < t; ++a) {
+			let t = e[a];
+			t !== r && (r = t, i = Math.max(a - n, i), n = a);
+		}
+		return Math.max(t - n, i);
+	}
+	tensorShapeFromTensor(e, t, n = !0) {
+		if (t.length === 0) {
+			if (e[0] === -1) return [];
+			throw Error("The only valid scalar shape tensor is the fully unknown shape specified as -1.");
+		}
+		return an(e, n);
+	}
+	calculateOutputSize(e) {
+		let t = this.valuesShape, n = this.defaultValueShape;
+		Se(n, t);
+		let r = this.tensorShapeFromTensor(this.shape, this.shapeShape), i = Le(this.raggedRank, r, t);
+		i[0] < 0 && (i[0] = e);
+		for (let e = 1; e <= this.raggedRank; ++e) i[e] < 0 && (i[e] = this.getMaxWidth(e));
+		return i;
+	}
+	calculateFirstParentOutputIndex(e, t, n) {
+		let r = Math.min(e, n), i = [], a = 0;
+		for (let e = 0; e < r; ++e, a += t) i.push(a);
+		for (let t = r; t < e; ++t) i.push(-1);
+		return b(i.length === e, () => "Final length of result must be equal to firstDimension."), i;
+	}
+	calculateOutputIndexRowSplit(e, t, n, r) {
+		let i = e.length, a = [];
+		for (let o = 0; o < i - 1; ++o) {
+			let i = e[o + 1] - e[o], s = Math.min(r, i), c = t[o];
+			c === -1 && (s = 0);
+			for (let e = 0; e < s; ++e) a.push(c), c += n;
+			for (let e = 0; e < i - s; ++e) a.push(-1);
+		}
+		if (i > 0 && a.length !== e[i - 1]) throw Error("Invalid row split size.");
+		return a;
+	}
+	calculateOutputIndexValueRowID(e, t, n, r) {
+		let i = e.length, a = [];
+		if (i === 0) return [];
+		let o = 0, s = e[0];
+		if (s >= t.length) throw Error(`Got currentValueRowId=${s}, which is not less than ${t.length}`);
+		let c = t[s];
+		a.push(c);
+		for (let l = 1; l < i; ++l) {
+			let i = e[l];
+			if (i === s) c >= 0 && (++o, o < r ? c += n : c = -1);
+			else {
+				if (o = 0, s = i, i >= t.length) throw Error(`Got nextValueRowId=${i} which is not less than ${t.length}`);
+				c = t[i];
+			}
+			a.push(c);
+		}
+		if (a.length !== e.length) throw Error("Invalid row ids.");
+		return a;
+	}
+	calculateOutputIndex(e, t, n, r) {
+		let i = this.getRowPartitionTensor(e), a = this.getRowPartitionTypeByDimension(e);
+		switch (a) {
+			case Z.VALUE_ROWIDS: return this.calculateOutputIndexValueRowID(i, t, n, r);
+			case Z.ROW_SPLITS:
+				if (i.length - 1 > t.length) throw Error(`Row partition size is greater than output size: ${i.length - 1} > ${t.length}`);
+				return this.calculateOutputIndexRowSplit(i, t, n, r);
+			default: throw Error(`Unsupported partition type: ${Z[a]}`);
+		}
+	}
+	getFirstDimensionSize() {
+		let e = this.rowPartitionValues[0];
+		if (this.rowPartitionTypes.length === 0) throw Error("No row_partition_types given.");
+		let t = this.rowPartitionTypes[0];
+		switch (t) {
+			case Z.FIRST_DIM_SIZE: return e[0];
+			case Z.VALUE_ROWIDS: throw Error("Cannot handle VALUE_ROWIDS in first dimension.");
+			case Z.ROW_SPLITS: return this.rowPartitionValuesShapes[0][0] - 1;
+			default: throw Error(`Cannot handle type ${Z[t]}`);
+		}
+	}
+	compute() {
+		if (this.rowPartitionValues[0].length <= 0) throw Error("Invalid first partition input. Tensor requires at least one element.");
+		let e = this.getFirstDimensionSize(), t = this.calculateOutputSize(e), n = Array(this.raggedRank + 1);
+		n[n.length - 1] = 1;
+		for (let e = n.length - 2; e >= 0; --e) n[e] = n[e + 1] * t[e + 1];
+		let r = an(t, !1), a = i(this.valuesDType, k(r));
+		if (n[0] * t[0] > 0) {
+			let i = this.calculateFirstParentOutputIndex(e, n[0], t[0]);
+			for (let e = 1; e <= this.raggedRank; ++e) i = this.calculateOutputIndex(e - 1, i, n[e], t[e]);
+			this.setOutput(this.raggedRank, i, a, r);
+		}
+		return [r, a];
+	}
+	setOutput(e, t, n, r) {
+		if (n.length === 0) return;
+		let i = this.values, a = n, o = r.slice();
+		o = o.slice(e + 1);
+		let s = k(o), c = t.length, l = this.defaultValue;
+		if (l.length !== s && l.length !== 1) {
+			let e = this.defaultValueShape;
+			se(() => {
+				l = ye(ae(l, e), o).dataSync();
+			});
+		}
+		let u = 0, d = 0, f = 0;
+		for (let e = 0; e <= c; ++e) {
+			let r = e < c ? t[e] : -1;
+			if (r === f) {
+				++f;
+				continue;
+			}
+			if (d < f) {
+				let e = i.subarray(u * s);
+				rn(a.subarray(d * s), e, (f - d) * s);
+			}
+			if (e >= c) {
+				let e = n.length;
+				r = Math.floor(e / s);
+			}
+			if (r > f) if (this.defaultValue.length === 1) a.subarray(f * s, r * s).fill(this.defaultValue[0]), f = r;
+			else for (; r > f;) rn(a.slice(f * s), l, s), ++f;
+			r < 0 ? (u = e + 1, d = f) : (u = e, d = f, f = d + 1);
+		}
+	}
+};
+function rn(e, t, n) {
+	for (let r = 0; r < n; r++) e[r] = t[r];
+}
+function an(e, t) {
+	let n = [];
+	for (let r of e) {
+		if (r < 0) {
+			if (!t) throw Error(`Dimension ${r} must be >= 0`);
+			if (r < -1) throw Error(`Dimension ${r} must be >= -1`);
+			r = -1;
+		}
+		n.push(r);
+	}
+	return n;
+}
+function on(e, t, n, r, i, a, o, s, c, l) {
+	return new nn(e, t, n, r, i, a, o, s, c, l).compute();
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Range_impl.js
+function sn(e, t, r, i) {
+	if (e === t || e < t && r < 0 || t < e && r > 1) return n(0, i);
+	let a = n(Math.abs(Math.ceil((t - e) / r)), i);
+	t < e && r === 1 && (r = -1), a[0] = e;
+	for (let e = 1; e < a.length; e++) a[e] = a[e - 1] + r;
+	return a;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Rsqrt.js
+var cn = G((e) => 1 / Math.sqrt(e)), ln = {
+	kernelName: m,
+	backendName: "cpu",
+	kernelFunc: q(m, cn)
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Scatter_impl.js
+function un(e, t, n, r, i, a, o, s, c, l) {
+	let u = [r / i, i], d = e.values, f = t.values;
+	if (r === 0) return E(n, t.dtype);
+	let p = c instanceof C ? c : E(u, t.dtype);
+	typeof c == "string" || typeof c == "number" ? p.values.fill(c) : typeof c == "boolean" && p.values.fill(+c);
+	for (let e = 0; e < a; e++) {
+		let a = [], c = 0;
+		for (let t = 0; t < o; t++) {
+			let n = d[e * o + t];
+			a.push(n), c += n * s[t];
+		}
+		if (c < 0 || c >= r / i) throw Error(`Invalid indices: ${a} does not index into ${n}`);
+		for (let n = 0; n < i; n++) l ? p.values[c * i + n] += f[e * i + n] : p.values[c * i + n] = t.rank === 0 ? f[0] : f[e * i + n];
+	}
+	return p;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Sigmoid.js
+var dn = G((e) => 1 / (1 + Math.exp(-e))), fn = K(t, (e) => 1 / (1 + Math.exp(-e))), pn = {
+	kernelName: t,
+	backendName: "cpu",
+	kernelFunc: fn
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Slice.js
+function mn(e, t, n, r, i) {
+	let a = ze(r, t, n), o = k(n), s = S(r);
+	if (a) {
+		let n = Be(t, s);
+		return i === "string" ? e.slice(n, n + o) : e.subarray(n, n + o);
+	}
+	let c = E(r, i, i === "string" ? P(e) : e), l = E(n, i);
+	for (let e = 0; e < l.size; ++e) {
+		let n = l.indexToLoc(e), r = n.map((e, n) => e + t[n]);
+		l.set(c.get(...r), ...n);
+	}
+	return i === "string" ? Me(l.values) : l.values;
+}
+function hn(e) {
+	let { inputs: t, backend: n, attrs: r } = e, { x: i } = t, { begin: a, size: o } = r;
+	I(i, "slice");
+	let [s, c] = Re(i, a, o);
+	Ve(i, s, c);
+	let l = n.data.get(i.dataId).values, u = mn(l, s, c, i.shape, i.dtype);
+	return n.makeTensorInfo(c, i.dtype, u);
+}
+var gn = {
+	kernelName: he,
+	backendName: "cpu",
+	kernelFunc: hn
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/SparseFillEmptyRows_impl.js
+function _n(e, t, n, r, a, o, s) {
+	let c = t[0], l = o[0], u = Array(l), d = Array(c), f = t[1];
+	if (l === 0) {
+		if (c !== 0) throw Error(Oe(c));
+		let e = i(n, 0), t = i(a, 0);
+		return [
+			e,
+			[0, f],
+			t,
+			u,
+			d
+		];
+	}
+	let p = !0, m = 0, h = Array(l).fill(0);
+	for (let t = 0; t < c; ++t) {
+		let n = e[t * f];
+		if (n < 0) throw Error(Te(t, n));
+		if (n >= l) throw Error(Ie(t, n, l));
+		++h[n], p &&= n >= m, m = n;
+	}
+	let g = !0;
+	for (let e = 0; e < l; ++e) {
+		let t = h[e] === 0;
+		u[e] = t, g &&= !t, h[e] = Math.max(h[e], 1), e > 0 && (h[e] += h[e - 1]);
+	}
+	if (g && p) {
+		let t = e, n = r;
+		for (let e = 0; e < c; ++e) d[e] = e;
+		return [
+			t,
+			[c, f],
+			n,
+			u,
+			d
+		];
+	} else {
+		let t = h[l - 1], o = i(n, t * f), p = i(a, t), m = Array(l).fill(0);
+		for (let t = 0; t < c; ++t) {
+			let n = e[t * f], i = m[n], a = (n === 0 ? 0 : h[n - 1]) + i;
+			m[n]++;
+			for (let n = 0; n < f; ++n) o[a * f + n] = e[t * f + n];
+			p[a] = r[t], d[t] = a;
+		}
+		for (let e = 0; e < l; ++e) if (m[e] === 0) {
+			let t = e === 0 ? 0 : h[e - 1];
+			o[t * f + 0] = e;
+			for (let e = 1; e < f; ++e) o[t * f + e] = 0;
+			p[t] = s;
+		}
+		return [
+			o,
+			[t, f],
+			p,
+			u,
+			d
+		];
+	}
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/SparseReshape_impl.js
+function vn(e, t, n, r, a) {
+	let o = k(r), s = t[0], c = a.length, l = [], u = 1, d = -1;
+	for (let e = 0; e < c; ++e) {
+		let t = a[e];
+		if (t === -1) {
+			if (d !== -1) throw Error(je(d, e));
+			d = e, l.push(1);
+		} else {
+			if (t < 0) throw Error(ke(e, t));
+			u *= t, l.push(t);
+		}
+	}
+	if (d !== -1) {
+		if (u <= 0) throw Error(Ee());
+		let e = Math.trunc(o / u);
+		if (u * e !== o) throw Error(Ne(r, l));
+		l[d] = e;
+	}
+	if (k(l) !== o) throw Error(De(r, l));
+	let f = r.length, p = [];
+	if (f > 0) {
+		p[f - 1] = 1;
+		for (let e = f - 2; e >= 0; --e) p[e] = p[e + 1] * r[e + 1];
+	}
+	let m = [];
+	if (c > 0) {
+		m[c - 1] = 1;
+		for (let e = c - 2; e >= 0; --e) m[e] = m[e + 1] * l[e + 1];
+	}
+	let h = i(n, s * c);
+	for (let t = 0; t < s; ++t) {
+		let n = 0;
+		for (let r = 0; r < f; ++r) n += e[t * f + r] * p[r];
+		for (let e = 0; e < c; ++e) h[t * c + e] = Math.trunc(n / m[e]), n %= m[e];
+	}
+	return [
+		h,
+		[s, c],
+		l
+	];
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/SparseSegmentReduction_impl.js
+function yn(e, t, n, r, a, o = !1, s = 0) {
+	let c = r.length, l = [t[0], e.length / t[0]], u = l[1], d = c > 0 ? a[c - 1] + 1 : 0;
+	if (d < 0) throw Error(N());
+	let f = t.slice();
+	f[0] = d;
+	let p = i(n, f.reduce((e, t) => e * t, 1));
+	if (c === 0) return d > 0 && p.fill(s), [p, f];
+	if (d <= 0) throw Error(N());
+	let m = 0, h = 1, g = 0, _ = a[m];
+	for (;;) {
+		let t = 0;
+		if (h < c) {
+			if (t = a[h], _ === t) {
+				++h;
+				continue;
+			}
+			if (_ >= t) throw Error(Ae());
+		}
+		if (_ < 0 || _ >= d) throw Error(Fe(_, d));
+		_ > g && p.fill(s, g * u, _ * u);
+		for (let t = m; t < h; ++t) {
+			let n = r[t];
+			if (n < 0 || n >= l[0]) throw Error(Pe(t, r[t], l[0]));
+			for (let t = 0; t < u; t++) p[_ * u + t] += e[n * u + t];
+		}
+		if (o) for (let e = 0; e < u; e++) p[_ * u + e] /= h - m;
+		if (m = h, ++h, g = _ + 1, _ = t, h > c) break;
+	}
+	return g < d && p.fill(s, g * u, d * u), [p, f];
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Sqrt.js
+var bn = G((e) => Math.sqrt(e)), xn = {
+	kernelName: ce,
+	backendName: "cpu",
+	kernelFunc: K(ce, (e) => Math.sqrt(e))
+}, Sn = L(((e, t) => {
+	let n = e - t;
+	return n * n;
+})), Cn = {
+	kernelName: de,
+	backendName: "cpu",
+	kernelFunc: U(de, Sn)
+}, wn = G((e, t) => {
+	let { pattern: n, replaceGlobal: r, rewrite: i } = t;
+	return e.replace(new RegExp(n, r ? "g" : ""), i);
+}), Tn = {
+	kernelName: ue,
+	backendName: "cpu",
+	kernelFunc: q(ue, wn)
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/StridedSlice_impl.js
+function En(e, t, n, r) {
+	let i = E(e, t.dtype);
+	for (let e = 0; e < i.size; e++) {
+		let a = i.indexToLoc(e), o = Array(a.length);
+		for (let e = 0; e < o.length; e++) o[e] = a[e] * n[e] + r[e];
+		i.set(t.get(...o), ...a);
+	}
+	return i;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/StringNGrams_impl.js
+var Dn = class {
+	constructor(e, t, n, r, i, a) {
+		this.separator = O(e), this.nGramWidths = t, this.leftPad = O(n), this.rightPad = O(r), this.padWidth = i, this.preserveShort = a;
+	}
+	getPadWidth(e) {
+		return Math.min(this.padWidth < 0 ? e - 1 : this.padWidth, e - 1);
+	}
+	getNumNGrams(e, t) {
+		let n = this.getPadWidth(t);
+		return Math.max(0, e + 2 * n - t + 1);
+	}
+	createNGrams(e, t, n, r, i, a) {
+		for (let o = 0; o < i; ++o) {
+			let s = this.getPadWidth(a), c = Math.max(0, s - o), l = Math.max(0, s - (i - (o + 1))), u = a - (c + l), d = t + (c > 0 ? 0 : o - s), f = 0;
+			f += c * this.leftPad.length;
+			for (let t = 0; t < u; ++t) f += e[d + t].length;
+			f += l * this.rightPad.length;
+			let p = c + l + u - 1;
+			f += p * this.separator.length, n[r + o] = new Uint8Array(f);
+			let m = n[r + o], h = 0, g = (e) => e.forEach((e) => m[h++] = e);
+			for (let e = 0; e < c; ++e) g(this.leftPad), g(this.separator);
+			for (let t = 0; t < u - 1; ++t) g(e[d + t]), g(this.separator);
+			if (u > 0) {
+				g(e[d + u - 1]);
+				for (let e = 0; e < l; ++e) g(this.separator), g(this.rightPad);
+			} else {
+				for (let e = 0; e < l - 1; ++e) g(this.rightPad), g(this.separator);
+				g(this.rightPad);
+			}
+		}
+	}
+	compute(e, t) {
+		let n = e.length, r = t.length;
+		if (r > 0) {
+			let e = t[0];
+			if (e !== 0) throw Error(`First split value must be 0, got ${e}`);
+			for (let i = 1; i < r; ++i) {
+				let r = t[i] >= e;
+				if (r &&= t[i] <= n, !r) throw Error(`Invalid split value ${t[i]}, must be in [${e}, ${n}]`);
+				e = t[i];
+			}
+			if (e !== n) throw Error(`Last split value must be data size. Expected ${n}, got ${e}`);
+		}
+		let a = r - 1, o = i("int32", r);
+		if (n === 0 || r === 0) {
+			let e = Array(n);
+			for (let e = 0; e <= a; ++e) o[e] = 0;
+			return [e, o];
+		}
+		o[0] = 0;
+		for (let e = 1; e <= a; ++e) {
+			let n = t[e] - t[e - 1], r = 0;
+			this.nGramWidths.forEach((e) => {
+				r += this.getNumNGrams(n, e);
+			}), this.preserveShort && n > 0 && r === 0 && (r = 1), o[e] = o[e - 1] + r;
+		}
+		let s = Array(o[a]);
+		for (let n = 0; n < a; ++n) {
+			let r = t[n], i = o[n];
+			if (this.nGramWidths.forEach((a) => {
+				let o = t[n + 1] - t[n], c = this.getNumNGrams(o, a);
+				this.createNGrams(e, r, s, i, c, a), i += c;
+			}), this.preserveShort && i === o[n]) {
+				let a = t[n + 1] - t[n];
+				if (a === 0) continue;
+				let o = a + 2 * this.padWidth;
+				this.createNGrams(e, r, s, i, 1, o);
+			}
+		}
+		return [s, o];
+	}
+};
+function Q(e, t, n, r, i, a, o, s) {
+	return new Dn(n, r, i, a, o, s).compute(e, t);
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/StringSplit_impl.js
+function On(e, t, n, r) {
+	if (!e.length) return;
+	if (t.length === 0) {
+		for (let t = 0; t < e.length; ++t) r.push(e.subarray(t, t + 1));
+		return;
+	}
+	if (t.length === 1) {
+		let i = t[0], a = e.indexOf(i);
+		for (; a !== -1;) {
+			let t = e.subarray(0, a);
+			(!n || t.length !== 0) && r.push(t), e = e.subarray(a + 1), a = e.indexOf(i);
+		}
+		(!n || e.length !== 0) && r.push(e);
+		return;
+	}
+	let i = 0;
+	for (let a = 0; a < e.length + 1; a++) if (a === e.length || t.indexOf(e[a]) !== -1) {
+		let t = e.subarray(i, a);
+		(!n || t.length !== 0) && r.push(t), i = a + 1;
+	}
+}
+function kn(e, t, n) {
+	let r = e.length, a = [], o = 0, s = 0, c = Array(r);
+	for (let i = 0; i < r; ++i) {
+		let r = a.length;
+		On(e[i], t, n, a);
+		let l = a.length - r;
+		c[i] = l, o += l, s = Math.max(s, l);
+	}
+	let l = i("int32", o * 2), u = Array(o), d = [r, s], f = 0;
+	for (let e = 0; e < r; ++e) for (let t = 0; t < c[e]; ++t) l[f * 2] = e, l[f * 2 + 1] = t, u[f] = a[f], ++f;
+	return [
+		l,
+		u,
+		d
+	];
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/StringToHashBucketFast_impl.js
+function An(e, t) {
+	let n = i("int32", e.length);
+	for (let r = 0; r < e.length; ++r) n[r] = y(e[r]).modulo(t).getLowBitsUnsigned();
+	return n;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Sub.js
+var jn = L(((e, t) => e - t)), Mn = U("Sub", jn, W(((e, t, n, r) => ({
+	real: e - n,
+	imag: t - r
+})))), Nn = {
+	kernelName: "Sub",
+	backendName: "cpu",
+	kernelFunc: Mn
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Tile_impl.js
+function Pn(e, t) {
+	let n = Array(e.rank);
+	for (let r = 0; r < n.length; r++) n[r] = e.shape[r] * t[r];
+	let r = E(n, e.dtype);
+	for (let t = 0; t < r.values.length; ++t) {
+		let n = r.indexToLoc(t), i = Array(e.rank);
+		for (let t = 0; t < i.length; t++) i[t] = n[t] % e.shape[t];
+		let a = e.locToIndex(i);
+		r.values[t] = e.values[a];
+	}
+	return r;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/TopK_impl.js
+var $ = (e, t) => {
+	let n = t.value - e.value;
+	return n === 0 ? e.index - t.index : n;
+};
+function Fn(e, t, n = 0, r = e.length - 1) {
+	for (; r > n;) {
+		if (r - n > 600) {
+			let i = r - n + 1, a = t - n + 1, o = Math.log(i), s = .5 * Math.exp(2 * o / 3), c = .5 * Math.sqrt(o * s * (i - s) / i) * Math.sign(a - i / 2);
+			Fn(e, t, Math.max(n, Math.floor(t - a * s / i + c)), Math.min(r, Math.floor(t + (i - a) * s / i + c)));
+		}
+		let i = e[t], a = n, o = r;
+		for (A(e, n, t), $(e[r], i) > 0 && A(e, n, r); a < o;) {
+			for (A(e, a, o), a++, o--; $(e[a], i) < 0;) a += 1;
+			for (; $(e[o], i) > 0;) --o;
+		}
+		$(e[n], i) === 0 ? A(e, n, o) : (o += 1, A(e, o, r)), o <= t && (n = o + 1), t <= o && (r = o - 1);
+	}
+}
+function In(e, t, n, r, i) {
+	let a = t[t.length - 1], [o, s] = [e.length / a, a], c = T(n, o * r), l = T("int32", o * r);
+	for (let t = 0; t < o; t++) {
+		let n = t * s, a = e.subarray(n, n + s), o = Array(a.length);
+		a.forEach((e, t) => o[t] = {
+			value: e,
+			index: t
+		}), r < o.length && (Fn(o, r), o = o.slice(0, r)), i && o.sort($);
+		let u = t * r, d = c.subarray(u, u + r), f = l.subarray(u, u + r);
+		for (let e = 0; e < r; e++) d[e] = o[e].value, f[e] = o[e].index;
+	}
+	let u = t.slice();
+	return u[u.length - 1] = r, [E(u, n, c), E(u, "int32", l)];
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Unique_impl.js
+function Ln(e, t, n, r) {
+	let i = pe(t, n)[0], a = [
+		1,
+		n[0],
+		1
+	];
+	for (let e = 0; e < i; e++) a[0] *= n[e];
+	a[1] = n[i];
+	for (let e = i + 1; e < n.length; e++) a[2] *= n[e];
+	let o = /* @__PURE__ */ new Map(), s = new Int32Array(n[i]), c = new C(a, r, e), l = [], u = a[0] === 1 && a[2] === 1;
+	for (let t = 0; t < n[i]; t++) {
+		let n;
+		if (u) n = e[t].toString();
+		else {
+			let e = [];
+			for (let n = 0; n < a[0]; n++) for (let r = 0; r < a[2]; r++) e.push(c.get(n, t, r));
+			n = e.join(",");
+		}
+		let r = o.get(n);
+		if (r != null) s[t] = r;
+		else {
+			let e = o.size;
+			o.set(n, e), s[t] = e, l.push(t);
+		}
+	}
+	let d = a.slice();
+	d[1] = o.size;
+	let f = new C(d, r);
+	l.forEach((e, t) => {
+		for (let n = 0; n < a[0]; n++) for (let r = 0; r < a[2]; r++) f.set(c.get(n, e, r), n, t, r);
+	});
+	let p = n.slice();
+	return p[i] = d[1], {
+		outputValues: f.values,
+		outputShape: p,
+		indices: s
+	};
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-cpu/dist/shared.js
+var Rn = /* @__PURE__ */ e({
+	addImpl: () => Ye,
+	bincountImpl: () => Qe,
+	bincountReduceImpl: () => $e,
+	bitwiseAndImpl: () => et,
+	castImpl: () => qe,
+	ceilImpl: () => nt,
+	concatImpl: () => it,
+	equalImpl: () => at,
+	expImpl: () => ct,
+	expm1Impl: () => dt,
+	floorDivImpl: () => ht,
+	floorImpl: () => pt,
+	gatherNdImpl: () => _t,
+	gatherV2Impl: () => vt,
+	greaterEqualImpl: () => xt,
+	greaterImpl: () => yt,
+	lessEqualImpl: () => Tt,
+	lessImpl: () => Ct,
+	linSpaceImpl: () => Dt,
+	logImpl: () => Ot,
+	maxImpl: () => At,
+	maximumImpl: () => jt,
+	minimumImpl: () => Nt,
+	multiplyImpl: () => J,
+	negImpl: () => Lt,
+	notEqualImpl: () => Bt,
+	prodImpl: () => Ut,
+	raggedGatherImpl: () => $t,
+	raggedRangeImpl: () => tn,
+	raggedTensorToTensorImpl: () => on,
+	rangeImpl: () => sn,
+	rsqrtImpl: () => cn,
+	scatterImpl: () => un,
+	sigmoidImpl: () => dn,
+	simpleAbsImpl: () => He,
+	sliceImpl: () => mn,
+	sparseFillEmptyRowsImpl: () => _n,
+	sparseReshapeImpl: () => vn,
+	sparseSegmentReductionImpl: () => yn,
+	sqrtImpl: () => bn,
+	squaredDifferenceImpl: () => Sn,
+	staticRegexReplaceImpl: () => wn,
+	stridedSliceImpl: () => En,
+	stringNGramsImpl: () => Q,
+	stringSplitImpl: () => kn,
+	stringToHashBucketFastImpl: () => An,
+	subImpl: () => jn,
+	tileImpl: () => Pn,
+	topKImpl: () => In,
+	transposeImpl: () => Y,
+	uniqueImpl: () => Ln
+});
+//#endregion
+export { it as $, Y as A, Et as B, sn as C, Gt as D, $t as E, Pt as F, _t as G, St as H, Mt as I, ft as J, gt as K, At as L, zt as M, Ft as N, X as O, It as P, st as Q, kt as R, ln as S, tn as T, bt as U, wt as V, vt as W, ut as X, lt as Y, ot as Z, hn as _, L as _t, Mn as a, Xe as at, pn as b, kn as c, H as ct, Tn as d, Ke as dt, rt as et, Cn as f, B as ft, _n as g, We as gt, vn as h, R as ht, Pn as i, $e as it, Vt as j, Ht as k, Q as l, Je as lt, yn as m, z as mt, Ln as n, tt as nt, Nn as o, Ze as ot, xn as p, Ge as pt, mt as q, In as r, Qe as rt, An as s, U as st, Rn as t, K as tt, En as u, V as ut, gn as v, Ue as vt, on as w, un as x, fn as y, I as yt, Dt as z };