@genai-fi/nanogpt 0.9.0 → 0.10.0

package/dist/sin-BGfy2HZo.js

@@ -0,0 +1,16 @@
+import { A as o, B as t, E as r } from "./index-ZyQhjEPo.js";
+import { l as i, n as a } from "./tensor_util-DV-FP5Q3.js";
+function e(n) {
+  const s = { x: t(n, "x", "cos", "float32") };
+  return r.runKernel(i, s);
+}
+const p = /* @__PURE__ */ o({ cos_: e });
+function x(n) {
+  const s = { x: t(n, "x", "sin", "float32") };
+  return r.runKernel(a, s);
+}
+const l = /* @__PURE__ */ o({ sin_: x });
+export {
+  p as c,
+  l as s
+};

package/dist/slice-D_gkkqZK.js

@@ -0,0 +1,13 @@
+import { A as c, B as e, E as a } from "./index-ZyQhjEPo.js";
+import { f as l } from "./tensor_util-DV-FP5Q3.js";
+function p(s, o, n) {
+  const r = e(s, "x", "slice", "string_or_numeric");
+  if (r.rank === 0)
+    throw new Error("Slicing scalar is not possible");
+  const t = { x: r }, i = { begin: o, size: n };
+  return a.runKernel(l, t, i);
+}
+const u = /* @__PURE__ */ c({ slice_: p });
+export {
+  u as s
+};

package/dist/slice_util-DtEldBfK.js

@@ -0,0 +1,261 @@
+import { a as E, k as x } from "./tensor-DdQUJZlz.js";
+const N = -2, L = -1;
+function P(n, e, i) {
+  const r = n.shape.length;
+  E(r === e.length, () => `Error in slice${r}D: Length of begin ${e} must match the rank of the array (${r}).`), E(r === i.length, () => `Error in slice${r}D: Length of size ${i} must match the rank of the array (${r}).`);
+  for (let t = 0; t < r; ++t)
+    E(e[t] + i[t] <= n.shape[t], () => `Error in slice${r}D: begin[${t}] + size[${t}] (${e[t] + i[t]}) would overflow input.shape[${t}] (${n.shape[t]})`);
+}
+function j(n) {
+  const e = [];
+  let i = 0;
+  for (; n > 0; )
+    n & 1 && e.push(i), n /= 2, i++;
+  return e;
+}
+function z(n, e, i) {
+  const r = [];
+  for (let t = 0; t < n.length; t++)
+    r[t] = Math.ceil((e[t] - n[t]) / i[t]);
+  return r;
+}
+function V(n, e, i, r) {
+  const t = [...n];
+  for (let o = t.length; o < r.length; o++)
+    t.push(1);
+  for (let o = 0; o < i; o++)
+    o === 0 ? t[e] = 1 : (t.splice(
+      e,
+      0,
+      1
+      /* element to add */
+    ), t.pop());
+  return t;
+}
+function D(n, e, i) {
+  return i <= n ? i : i - (e - 1);
+}
+function O(n, e) {
+  const i = [];
+  for (let r = 0; r < n; r++)
+    i.push(e + r);
+  return i;
+}
+function B(n, e, i, r, t, o, a, f, c) {
+  const h = n.length;
+  let S = new Array(h), g = new Array(h), s = new Array(h);
+  if (e.length && i > 0) {
+    const u = e[0], p = i + 1;
+    S = T(a, u, p, r, n), g = R(f, u, p, t, n), s = V(o, u, p, n);
+  } else
+    for (let u = 0; u < h; u++)
+      S[u] = W(a, r, o, n, u, c), g[u] = v(f, t, o, n, u, c), s[u] = X(o, u, c);
+  return {
+    begin: S,
+    end: g,
+    strides: s
+  };
+}
+function T(n, e, i, r, t) {
+  const o = [...t], a = O(i, e);
+  for (let f = 0; f < o.length; f++)
+    if (a.indexOf(f) > -1)
+      o[f] = 0;
+    else {
+      const c = D(e, i, f);
+      let h = r[c];
+      n & 1 << c && (h = 0), o[f] = h;
+    }
+  return o;
+}
+function R(n, e, i, r, t) {
+  const o = [...t], a = O(i, e);
+  for (let f = 0; f < o.length; f++)
+    if (a.indexOf(f) > -1)
+      o[f] = Number.MAX_SAFE_INTEGER;
+    else {
+      const c = D(e, i, f);
+      let h = r[c];
+      n & 1 << c && (h = Number.MAX_SAFE_INTEGER), o[f] = h;
+    }
+  for (let f = 0; f < o.length; f++) {
+    const c = t[f];
+    o[f] < 0 && (o[f] += c), o[f] = x(0, o[f], t[f]);
+  }
+  return o;
+}
+function X(n, e, i) {
+  let r = n[e];
+  return (i & 1 << e || r == null) && (r = 1), r;
+}
+function W(n, e, i, r, t, o) {
+  let a = e[t];
+  const f = i[t] || 1;
+  (n & 1 << t || o & 1 << t || a == null) && (f > 0 ? a = Number.MIN_SAFE_INTEGER : a = Number.MAX_SAFE_INTEGER);
+  const c = r[t];
+  return a < 0 && (a += c), a = x(0, a, c - 1), a;
+}
+function v(n, e, i, r, t, o) {
+  let a = e[t];
+  const f = i[t] || 1;
+  (n & 1 << t || o & 1 << t || a == null) && (f > 0 ? a = Number.MAX_SAFE_INTEGER : a = Number.MIN_SAFE_INTEGER);
+  const c = r[t];
+  return a < 0 && (a += c), f > 0 ? a = x(0, a, c) : a = x(-1, a, c - 1), a;
+}
+function C(n, e, i) {
+  let r = i.length;
+  for (let t = 0; t < i.length; t++)
+    if (i[t] > 1) {
+      r = t;
+      break;
+    }
+  for (let t = r + 1; t < i.length; t++)
+    if (e[t] > 0 || i[t] !== n[t])
+      return !1;
+  return !0;
+}
+function H(n, e) {
+  let i = n.length > 0 ? n[n.length - 1] : 1;
+  for (let r = 0; r < n.length - 1; r++)
+    i += n[r] * e[r];
+  return i;
+}
+function K(n, e, i) {
+  let r;
+  const t = n.shape.length;
+  typeof e == "number" ? r = [e, ...new Array(t - 1).fill(0)] : e.length < t ? r = e.concat(new Array(t - e.length).fill(0)) : r = e.slice(), r.forEach((a) => {
+    E(a !== -1, () => "slice() does not support negative begin indexing.");
+  });
+  let o;
+  return i == null ? o = new Array(t).fill(-1) : typeof i == "number" ? o = [i, ...new Array(t - 1).fill(-1)] : i.length < t ? o = i.concat(new Array(t - i.length).fill(-1)) : o = i, o = o.map((a, f) => a >= 0 ? a : (E(a === -1, () => `Negative size values should be exactly -1 but got ${a} for the slice() size at index ${f}.`), n.shape[f] - r[f])), [r, o];
+}
+function q(n, e, i, r, t, o, a, f, c) {
+  let h;
+  if (r == null ? (h = new Array(e.length), h.fill(1)) : h = r, a != null && (a & a - 1) !== 0)
+    throw new Error("Multiple ellipses in slice is not allowed.");
+  let S = !1;
+  const g = {
+    dims: h.length,
+    numAddAxisAfterEllipsis: 0,
+    begin: e.slice(),
+    end: i.slice(),
+    strides: h.slice(),
+    beginMask: t,
+    endMask: o,
+    ellipsisMask: a,
+    newAxisMask: f,
+    shrinkAxisMask: c
+  };
+  for (let l = 0; l < g.dims; l++)
+    S && (1 << l & f) !== 0 && g.numAddAxisAfterEllipsis++, 1 << l & a && (S = !0);
+  S || (g.ellipsisMask |= 1 << g.dims, g.dims++);
+  const s = {
+    dims: n.length,
+    beginMask: 0,
+    endMask: 0,
+    beginValid: !1,
+    endValid: !1
+  };
+  J(g, s);
+  let u = !0, p = !0, M = !0;
+  const I = [], w = [];
+  for (let l = 0; l < n.length; ++l) {
+    if (s.strides[l] === 0)
+      throw Error(`strides[${l}] must be non-zero`);
+    const m = !!(s.shrinkAxisMask & 1 << l), d = n[l];
+    if (d === -1) {
+      I.push(m ? 1 : -1);
+      continue;
+    }
+    const _ = [s.beginMask & 1 << l, s.endMask & 1 << l], $ = [
+      s.strides[l] > 0 ? 0 : -1,
+      s.strides[l] > 0 ? d : d - 1
+    ];
+    if (m && s.strides[l] <= 0)
+      throw Error("only stride 1 allowed on non-range indexing.");
+    M = M && s.strides[l] === 1;
+    const y = !!(s.beginMask & 1 << l && s.endMask & 1 << l);
+    if (s.beginValid && s.endValid) {
+      if (m) {
+        const G = s.begin[l] < 0 ? d + s.begin[l] : s.begin[l];
+        if (s.begin[l] = G, s.end[l] = s.begin[l] + 1, G < 0 || G >= d)
+          throw Error(`slice index ${s.begin[l]} of dimension ${l} out of bounds.`);
+      } else
+        s.begin[l] = F(s.begin[l], 0, s.strides[l], d, _, $), s.end[l] = F(s.end[l], 1, s.strides[l], d, _, $);
+      const b = s.strides[l] === 1 && s.begin[l] === 0 && s.end[l] === d;
+      u = u && b, p = p && (l === 0 && s.strides[l] === 1 || b);
+    } else
+      u = u && s.strides[l] === 1 && y, p = p && (l === 0 && s.strides[l] === 1 || y);
+    let A, k = !1;
+    if (s.beginValid && s.endValid ? (A = s.end[l] - s.begin[l], k = !0) : m ? (A = 1, k = !0) : y && d >= 0 && (s.strides[l] < 0 ? A = -d : A = d, k = !0), k) {
+      let b;
+      A === 0 || A < 0 != s.strides[l] < 0 ? b = 0 : b = Math.trunc(A / s.strides[l]) + (A % s.strides[l] !== 0 ? 1 : 0), I.push(b);
+    } else
+      I.push(-1);
+  }
+  for (let l = 0; l < s.finalShapeGatherIndices.length; ++l) {
+    const m = s.finalShapeGatherIndices[l];
+    m >= 0 ? w.push(I[m]) : m === N && w.push(1);
+  }
+  return {
+    finalShapeSparse: w.filter((l, m) => s.finalShapeGatherIndices[m] !== N),
+    finalShape: w,
+    isIdentity: u,
+    sliceDim0: p,
+    isSimpleSlice: M,
+    begin: s.begin,
+    end: s.end,
+    strides: s.strides
+  };
+}
+function J(n, e) {
+  e.beginMask = 0, e.endMask = 0, e.shrinkAxisMask = 0;
+  let i = 0;
+  e.beginValid = n.begin != null, e.endValid = n.end != null, e.begin = new Array(e.dims), e.end = new Array(e.dims), e.strides = new Array(e.dims), e.finalShapeGatherIndices = [], e.finalShapeGatherIndicesSparse = [], e.inputShapeGatherIndicesSparse = new Array(e.dims);
+  for (let r = 0; r < n.dims; r++)
+    if (1 << r & n.ellipsisMask) {
+      const t = Math.min(e.dims - (n.dims - r) + 1 + n.numAddAxisAfterEllipsis, e.dims);
+      for (; i < t; i++)
+        e.begin[i] = 0, e.end[i] = 0, e.strides[i] = 1, e.beginMask |= 1 << i, e.endMask |= 1 << i, e.finalShapeGatherIndices.push(i), e.finalShapeGatherIndicesSparse.push(-1), e.inputShapeGatherIndicesSparse[i] = r;
+    } else if (1 << r & n.newAxisMask)
+      e.finalShapeGatherIndices.push(N), e.finalShapeGatherIndicesSparse.push(-1);
+    else {
+      if (i === e.begin.length)
+        throw Error(`Index out of range using input dim ${i}; input has only ${e.dims} dims, ${e.begin.length}.`);
+      n.begin != null && (e.begin[i] = n.begin[r]), n.end != null && (e.end[i] = n.end[r]), e.strides[i] = n.strides[r], n.beginMask & 1 << r && (e.beginMask |= 1 << i), n.endMask & 1 << r && (e.endMask |= 1 << i), n.shrinkAxisMask & 1 << r ? (e.finalShapeGatherIndices.push(L), e.finalShapeGatherIndicesSparse.push(-1), e.shrinkAxisMask |= 1 << i) : (e.finalShapeGatherIndices.push(i), e.finalShapeGatherIndicesSparse.push(r)), e.inputShapeGatherIndicesSparse[i] = r, i++;
+    }
+}
+function F(n, e, i, r, t, o) {
+  if (t[e])
+    return i > 0 ? o[e] : o[e + 1 & 1];
+  {
+    const a = n < 0 ? r + n : n;
+    return a < o[0] ? o[0] : a > o[1] ? o[1] : a;
+  }
+}
+const Y = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  assertParamsValid: P,
+  computeFlatOffset: H,
+  computeOutShape: z,
+  getNormalizedAxes: B,
+  isSliceContinous: C,
+  maskToAxes: j,
+  parseSliceParams: K,
+  sliceInfo: q,
+  startForAxis: W,
+  startIndicesWithElidedDims: T,
+  stopForAxis: v,
+  stopIndicesWithElidedDims: R,
+  stridesForAxis: X,
+  stridesWithElidedDims: V
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  P as a,
+  q as b,
+  H as c,
+  z as d,
+  C as i,
+  K as p,
+  Y as s
+};

package/dist/softmax-ZHVebtR1.js

@@ -0,0 +1,13 @@
+import { A as r, B as f, E as i } from "./index-ZyQhjEPo.js";
+import { S as e } from "./tensor_util-DV-FP5Q3.js";
+function l(s, o = -1) {
+  const t = f(s, "logits", "softmax", "float32");
+  if (o === -1 && (o = t.rank - 1), o !== t.rank - 1)
+    throw Error(`Softmax along a non-last dimension is not yet supported. Logits was rank ${t.rank} and dim was ${o}`);
+  const n = { logits: t }, a = { dim: o };
+  return i.runKernel(e, n, a);
+}
+const c = /* @__PURE__ */ r({ softmax_: l });
+export {
+  c as s
+};

package/dist/split-DrfihRpZ.js

@@ -0,0 +1,10 @@
+import { A as p, B as i, E as c } from "./index-ZyQhjEPo.js";
+import { c as a } from "./tensor_util-DV-FP5Q3.js";
+function e(t, s, o = 0) {
+  const n = { x: i(t, "x", "split") }, r = { numOrSizeSplits: s, axis: o };
+  return c.runKernel(a, n, r);
+}
+const u = /* @__PURE__ */ p({ split_: e });
+export {
+  u as s
+};

package/dist/squeeze-DZEpeblb.js

@@ -0,0 +1,11 @@
+import { A as o, B as n } from "./index-ZyQhjEPo.js";
+import { r as t } from "./reshape-DevtBWtf.js";
+import { h as a } from "./tensor-DdQUJZlz.js";
+function p(r, s) {
+  const e = n(r, "x", "squeeze", "string_or_numeric");
+  return t(e, a(e.shape, s).newShape);
+}
+const c = /* @__PURE__ */ o({ squeeze_: p });
+export {
+  c as s
+};

package/dist/stack-yOIAalTq.js

@@ -0,0 +1,13 @@
+import { A as e, C as c, E as i } from "./index-ZyQhjEPo.js";
+import { P as m } from "./tensor_util-DV-FP5Q3.js";
+import { a as r } from "./tensor-DdQUJZlz.js";
+function f(o, s = 0) {
+  const t = c(o, "tensors", "stack", "string_or_numeric");
+  r(t.length >= 1, () => "Pass at least one tensor to tf.stack"), t.length > 0 && r(s <= t[0].rank, () => "Axis must be <= rank of the tensor");
+  const n = t, a = { axis: s };
+  return i.runKernel(m, n, a);
+}
+const l = /* @__PURE__ */ e({ stack_: f });
+export {
+  l as s
+};

package/dist/sum-_fzj5ZTB.js

@@ -0,0 +1,12 @@
+import { A as e, B as u, G as m, E as c } from "./index-ZyQhjEPo.js";
+import { g as i } from "./tensor_util-DV-FP5Q3.js";
+function l(t, o = null, n = !1) {
+  let s = u(t, "x", "sum");
+  s.dtype === "bool" && (s = m(s, "int32"));
+  const r = { x: s }, a = { axis: o, keepDims: n };
+  return c.runKernel(i, r, a);
+}
+const x = /* @__PURE__ */ e({ sum_: l });
+export {
+  x as s
+};