@genai-fi/nanogpt 0.9.0 → 0.10.0

package/dist/backend_util-D-rUb2ty.js

@@ -0,0 +1,474 @@
+import { s as m, i as w, L as I, a as d, A, t as _ } from "./tensor-DdQUJZlz.js";
+import { d as y, f as M, h as T, c as b, e as D, a as L, b as x, g as W } from "./axis_util-BvHEw88j.js";
+import { j as v, h as F, q as N } from "./index-ZyQhjEPo.js";
+import { a as C, c as P } from "./concat_util-DcJk7YHS.js";
+import { S as z, a as B, b as U, c as j, d as q, e as G, f as H, g as V, h as Z, i as k, j as J, k as K, l as X, m as Y, s as Q, n as ee, t as te } from "./selu_util-D1w6yyTO.js";
+import { s as se } from "./slice_util-DtEldBfK.js";
+import { a0 as ne, u as re, w as oe } from "./tensor_util-DV-FP5Q3.js";
+import { c as ae, v as ie, a as ue } from "./scatter_nd_util-5EL-8VAQ.js";
+import { a as le, c as pe, b as ce, e as he, d as fe, g as ge, m as de, s as me } from "./complex_util-Yc1A_gV1.js";
+function Ee(e, t) {
+  const r = e.shape.length, s = t.shape.length;
+  if (r < 1)
+    throw new Error(`tf.gatherND() expects the input to be rank 1 or higher, but the rank was ${r}.`);
+  if (s < 1)
+    throw new Error(`tf.gatherND() expects the indices to be rank 1 or higher, but the rank was ${s}.`);
+  if (t.dtype !== "int32")
+    throw new Error(`tf.gatherND() expects the indices to be int32 type, but the dtype was ${t.dtype}.`);
+  if (t.shape[s - 1] > r)
+    throw new Error(`index innermost dimension length must be <= tensor rank; saw: ${t.shape[s - 1]} vs. ${r}`);
+  if (m(e.shape) === 0)
+    throw new Error(`Requested more than 0 entries, but input is empty. Input shape: ${e.shape}.`);
+  const n = t.shape, o = n[n.length - 1];
+  let a = 1;
+  for (let i = 0; i < n.length - 1; ++i)
+    a *= n[i];
+  const u = e.shape, p = n.slice();
+  p.pop();
+  let c = 1;
+  for (let i = o; i < r; ++i)
+    c *= u[i], p.push(u[i]);
+  const g = [
+    ...w(e.shape).map((i) => i / c),
+    1
+  ].slice(0, o);
+  return [p, a, c, g];
+}
+var f;
+(function(e) {
+  e[e.FIRST_DIM_SIZE = 0] = "FIRST_DIM_SIZE", e[e.VALUE_ROWIDS = 1] = "VALUE_ROWIDS", e[e.ROW_LENGTHS = 2] = "ROW_LENGTHS", e[e.ROW_SPLITS = 3] = "ROW_SPLITS", e[e.ROW_LIMITS = 4] = "ROW_LIMITS", e[e.ROW_STARTS = 5] = "ROW_STARTS";
+})(f || (f = {}));
+function Ie(e, t, r) {
+  let s = new Array();
+  if (r == null && t == null)
+    return s;
+  if (t == null)
+    for (; s.length < e + r.length; )
+      s.push(-1);
+  else
+    s = t.slice();
+  if (r == null)
+    return s;
+  if (e + r.length !== s.length)
+    throw new Error(`rt input.shape and shape=${t} are incompatible: rt input.rank = ${e + r.length}, but shape.rank = ${s.length}`);
+  for (let n = 1; n < r.length; ++n) {
+    const o = r[n], a = s[s.length - r.length + n], u = s[a];
+    if (o >= 0)
+      if (u >= 0) {
+        if (u !== o)
+          throw new Error(`rt input.shape and shape=${t} are incompatible: rt input.shape[${n + e}] = ${o} but shape[${n + e}] = ${u}`);
+      } else
+        s[a] = o;
+  }
+  return s;
+}
+function $e(e) {
+  const t = {
+    FIRST_DIM_SIZE: f.FIRST_DIM_SIZE,
+    VALUE_ROWIDS: f.VALUE_ROWIDS,
+    ROW_LENGTHS: f.ROW_LENGTHS,
+    ROW_SPLITS: f.ROW_SPLITS,
+    ROW_LIMITS: f.ROW_LIMITS,
+    ROW_STARTS: f.ROW_STARTS
+  }, r = [];
+  for (const s of e)
+    if (s in t)
+      r.push(t[s]);
+    else
+      break;
+  return r;
+}
+function Se(e) {
+  return e.length === 0 ? 0 : e[0] === f.FIRST_DIM_SIZE ? e.length - 1 : e.length;
+}
+function Re(e, t) {
+  if (e == null || t == null)
+    return;
+  const r = e.length, s = t.length;
+  if (r >= s)
+    throw new Error(`defaultValue.shape=${e} and ragged tensor flatValues.shape=${t}, are incompatible: defaultValue.rank = ${r} must be less than ragged tensor input flatValues.rank = ${s})`);
+  for (let n = 0; n < Math.min(r, s - 1); ++n) {
+    const o = e[n], a = t[n + 1];
+    if (o >= 0 && a >= 0 && o !== 1 && o !== a)
+      throw new Error(`defaultValue.shape=${e}, and ragged tensor input flatValues.shape=${t} are incompatible: defaultValue.shape[${n - e.length}] = ${o} but ragged tensor input.flatValues.shape[${n - e.length}] = ${a}`);
+  }
+}
+const $ = 30;
+function Oe(e) {
+  return e <= $ ? e : I(e, Math.floor(Math.sqrt(e)));
+}
+function we(e, t, r) {
+  const s = r * (typeof e == "number" ? e : e[0]), n = t * (typeof e == "number" ? e : e[1]);
+  return [s, n];
+}
+function Ae(e, t, r, s = !0) {
+  let n = [];
+  if (s)
+    n = n.concat(t.slice(0)), n.push(e[0] / r), n = n.concat(e.slice(1));
+  else {
+    n = n.concat(e[0]);
+    const o = t.length;
+    for (let a = 0; a < o; ++a)
+      n = n.concat([e[a + 1] / t[a], t[a]]);
+    n = n.concat(e.slice(o + 1));
+  }
+  return n;
+}
+function _e(e, t, r = !0) {
+  const s = [];
+  if (r) {
+    s.push(t);
+    for (let n = t + 1; n < e; ++n)
+      n <= 2 * t ? (s.push(n), s.push(n - (t + 1))) : s.push(n);
+  } else {
+    const n = [], o = [];
+    for (let a = 1; a < e; ++a)
+      a >= t * 2 + 1 || a % 2 === 1 ? o.push(a) : n.push(a);
+    s.push(...n), s.push(0), s.push(...o);
+  }
+  return s;
+}
+function ye(e, t, r, s = !0) {
+  const n = [];
+  s ? n.push(e[0] / r) : n.push(e[0] * r);
+  for (let o = 1; o < e.length; ++o)
+    o <= t.length ? s ? n.push(t[o - 1] * e[o]) : n.push(e[o] / t[o - 1]) : n.push(e[o]);
+  return n;
+}
+function Me(e, t) {
+  const r = [0];
+  for (let s = 0; s < t; ++s)
+    r.push(e[s][0]);
+  return r;
+}
+function Te(e, t, r) {
+  const s = e.slice(0, 1);
+  for (let n = 0; n < r; ++n)
+    s.push(e[n + 1] - t[n][0] - t[n][1]);
+  return s;
+}
+const be = 0.3275911, De = 0.254829592, Le = -0.284496736, xe = 1.421413741, We = -1.453152027, ve = 1.061405429;
+const E = "->", Fe = /->/g, S = ",", R = "...";
+function Ne(e, t) {
+  e = e.replace(/\s/g, "");
+  const r = (e.length - e.replace(Fe, "").length) / E.length;
+  if (r < 1)
+    throw new Error("Equations without an arrow are not supported.");
+  if (r > 1)
+    throw new Error(`Equation must contain exactly one arrow ("${E}").`);
+  const [s, n] = e.split(E);
+  d(s.indexOf(R) === -1, () => `The ellipsis notation ("${R}") is not supported yet.`);
+  const o = s.split(S), a = o.length;
+  if (t !== a)
+    throw new Error(`Expected ${a} input tensors, received ${t}`);
+  if (a > 2)
+    throw new Error("Support for more than 2 input tensors is not implemented yet.");
+  const u = [];
+  for (let l = 0; l < n.length; ++l) {
+    const h = n[l];
+    if (!o.some((O) => O.indexOf(h) !== -1))
+      throw new Error(`Output subscripts contain the label ${h} not present in the input subscripts.`);
+    u.indexOf(h) === -1 && u.push(h);
+  }
+  for (let l = 0; l < s.length; ++l) {
+    const h = s[l];
+    u.indexOf(h) === -1 && h !== S && u.push(h);
+  }
+  const p = new Array(o.length);
+  for (let l = 0; l < a; ++l) {
+    if (new Set(o[l].split("")).size !== o[l].length)
+      throw new Error(`Found duplicate axes in input component ${o[l]}. Support for duplicate axes in input is not implemented yet.`);
+    p[l] = [];
+    for (let h = 0; h < o[l].length; ++h)
+      p[l].push(u.indexOf(o[l][h]));
+  }
+  const c = u.length, g = n.length, i = [];
+  for (let l = g; l < c; ++l)
+    i.push(l);
+  return { allDims: u, summedDims: i, idDims: p };
+}
+function Ce(e, t) {
+  let r = new Array(e);
+  r.fill(-1);
+  for (let n = 0; n < t.length; ++n)
+    r[t[n]] = n;
+  const s = [];
+  for (let n = 0; n < e; ++n)
+    r[n] === -1 && s.push(n);
+  return r = r.filter((n) => n !== -1), { permutationIndices: r, expandDims: s };
+}
+function Pe(e, t, r) {
+  const s = new Array(e);
+  for (let n = 0; n < r.length; ++n) {
+    const o = r[n].shape;
+    for (let a = 0; a < t[n].length; ++a)
+      s[t[n][a]] === void 0 ? s[t[n][a]] = o[a] : d(s[t[n][a]] === o[a], () => `Expected dimension ${s[t[n][a]]} at axis ${a} of input shaped ${JSON.stringify(o)}, but got dimension ${o[a]}`);
+  }
+}
+function ze(e, t) {
+  const r = e, s = [];
+  let n = 0;
+  e.length === 0 && r.push(-1), n = e.length + 1;
+  for (let a = 0; a < n; ++a)
+    s.push([]);
+  const o = [];
+  for (let a = 0; a < r.length; ++a) {
+    const u = r[a], p = Ue(t, u);
+    for (const c of p)
+      o.indexOf(c) === -1 && (s[a].push(c), o.push(c));
+  }
+  return { path: r, steps: s };
+}
+function Be(e) {
+  return e.every((t, r) => t === r);
+}
+function Ue(e, t) {
+  const r = [];
+  for (let s = 0; s < e.length; ++s)
+    (e[s].length === 0 || e[s].indexOf(t) !== -1 || t === -1) && r.push(s);
+  return r;
+}
+function je(e, t, r = 0) {
+  let s = [];
+  if (typeof t == "number")
+    d(e.shape[r] % t === 0, () => "Number of splits must evenly divide the axis."), s = new Array(t).fill(e.shape[r] / t);
+  else {
+    const n = t.reduce((a, u) => (u === -1 && (a += 1), a), 0);
+    d(n <= 1, () => "There should be only one negative value in split array.");
+    const o = t.indexOf(-1);
+    if (o !== -1) {
+      const a = t.reduce((u, p) => p > 0 ? u + p : u);
+      t[o] = e.shape[r] - a;
+    }
+    d(e.shape[r] === t.reduce((a, u) => a + u), () => "The sum of sizes must match the size of the axis dimension."), s = t;
+  }
+  return s;
+}
+function qe(e) {
+  return `Received SparseTensor with denseShape[0] = 0 but
+  indices.shape[0] = ${e}`;
+}
+function Ge(e, t) {
+  return `indices(${e}, 0) is invalid: ${t} < 0`;
+}
+function He(e, t, r) {
+  return `indices(${e}, 0) is invalid: ${t} >= ${r}`;
+}
+function Ve(e, t) {
+  return `only one output dimension may be -1, not both ${e} and ${t}`;
+}
+function Ze(e, t) {
+  return `size ${e} must be non-negative, not ${t}`;
+}
+function ke() {
+  return "reshape cannot infer the missing input size for an empty tensor unless all specified input sizes are non-zero";
+}
+function Je(e, t) {
+  const r = m(e), s = m(t);
+  return `Input to reshape is a SparseTensor with ${r}
+  dense values, but the requested shape requires a multiple of ${s}. inputShape=${e} outputShape= ${t}`;
+}
+function Ke(e, t) {
+  const r = m(e), s = m(t);
+  return `Input to reshape is a tensor with ${r} dense values, but the requested shape has ${s}. inputShape=${e} outputShape=${t}`;
+}
+function Xe() {
+  return "segment ids must be >= 0";
+}
+function Ye() {
+  return "segment ids are not increasing";
+}
+function Qe(e, t) {
+  return `Segment id ${e} out of range [0, ${t}), possibly because segmentIds input is not sorted.`;
+}
+function et(e, t, r) {
+  return `Bad: indices[${e}] == ${t} out of range [0, ${r})`;
+}
+function tt(e, t) {
+  let r = !1, s;
+  for (e <= $ ? (s = e, r = !0) : s = I(e, Math.floor(Math.sqrt(e))); !r; )
+    s > t || s === e ? r = !0 : s = I(e, s + 1);
+  return s;
+}
+function st(e, t, r) {
+  const s = [], n = e.length;
+  for (let o = 0; o < n; o++)
+    o !== t ? s.push(e[o]) : s.push(r);
+  return s;
+}
+function nt(e, t, r, s) {
+  const n = t.shape.length, o = e.shape.length;
+  if (s !== 0 && (s < -n || s > n))
+    throw new Error(`Expect batchDims in the range of [-${n}, ${n}], but got ${s}`);
+  if (s < 0 && (s += n), s > o)
+    throw new Error(`batchDims (${s}) must be less than rank(x) (
+    ${o}).`);
+  if (r < s)
+    throw new Error(`batchDims (${s}) must be less than or equal to axis (${r}).`);
+  for (let i = 0; i < s; ++i)
+    if (e.shape[i] !== t.shape[i])
+      throw new Error(`x.shape[${i}]: ${e.shape[i]} should be equal to indices.shape[${i}]: ${t.shape[i]}.`);
+  const a = e.shape[r], u = [];
+  let p = 1, c = 1, g = 1;
+  for (let i = 0; i < s; ++i)
+    u.push(e.shape[i]), p *= e.shape[i];
+  for (let i = s; i < r; i++)
+    u.push(e.shape[i]), c *= e.shape[i];
+  for (let i = s; i < n; i++)
+    u.push(t.shape[i]);
+  for (let i = r + 1; i < o; i++)
+    u.push(e.shape[i]), g *= e.shape[i];
+  return { batchSize: p, sliceSize: g, outerSize: c, dimSize: a, outputShape: u };
+}
+const rt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  collectGatherOpShapeInfo: nt,
+  computeOutShape: st,
+  segOpComputeOptimalWindowSize: tt
+}, Symbol.toStringTag, { value: "Module" }));
+function ot(e) {
+  try {
+    return e.map((t) => A(t));
+  } catch (t) {
+    throw new Error(`Failed to decode encoded string bytes into utf-8, error: ${t}`);
+  }
+}
+function at(e) {
+  return e.map((t) => _(t));
+}
+const mt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ERF_A1: De,
+  ERF_A2: Le,
+  ERF_A3: xe,
+  ERF_A4: We,
+  ERF_A5: ve,
+  ERF_P: be,
+  PARALLELIZE_THRESHOLD: $,
+  get RowPartitionType() {
+    return f;
+  },
+  SELU_SCALE: z,
+  SELU_SCALEALPHA: B,
+  applyActivation: U,
+  assertAndGetBroadcastShape: v,
+  assertAxesAreInnerMostDims: y,
+  assertParamsConsistent: C,
+  assignToTypedArray: le,
+  axesAreInnerMostDims: M,
+  calculateShapes: ae,
+  checkEinsumDimSizes: Pe,
+  checkPadOnDimRoundingMode: j,
+  combineLocations: T,
+  combineRaggedTensorToTensorShapes: Ie,
+  complexWithEvenIndex: pe,
+  complexWithOddIndex: ce,
+  computeConv2DInfo: q,
+  computeConv3DInfo: G,
+  computeDefaultPad: H,
+  computeDilation2DInfo: V,
+  computeOptimalWindowSize: Oe,
+  computeOutAndReduceShapes: b,
+  computeOutShape: P,
+  computePool2DInfo: Z,
+  computePool3DInfo: k,
+  convertConv2DDataFormat: J,
+  decodeEinsumEquation: Ne,
+  eitherStridesOrDilationsAreOne: K,
+  expandShapeToKeepDim: D,
+  exponent: he,
+  exponents: fe,
+  fromStringArrayToUint8: at,
+  fromUint8ToStringArray: ot,
+  getAxesPermutation: L,
+  getBroadcastDims: F,
+  getComplexWithIndex: ge,
+  getEinsumComputePath: ze,
+  getEinsumPermutation: Ce,
+  getFusedBiasGradient: X,
+  getFusedDyActivation: Y,
+  getImageCenter: we,
+  getInnerMostAxes: x,
+  getPermuted: _e,
+  getRaggedRank: Se,
+  getReductionAxes: N,
+  getReshaped: Ae,
+  getReshapedPermuted: ye,
+  getRowPartitionTypesHelper: $e,
+  getSliceBeginCoords: Me,
+  getSliceSize: Te,
+  getSparseFillEmptyRowsIndicesDenseShapeMismatch: qe,
+  getSparseFillEmptyRowsNegativeIndexErrorMessage: Ge,
+  getSparseFillEmptyRowsOutOfRangeIndexErrorMessage: He,
+  getSparseReshapeEmptyTensorZeroOutputDimErrorMessage: ke,
+  getSparseReshapeInputOutputMismatchErrorMessage: Ke,
+  getSparseReshapeInputOutputMultipleErrorMessage: Je,
+  getSparseReshapeMultipleNegativeOneOutputDimErrorMessage: Ve,
+  getSparseReshapeNegativeOutputDimErrorMessage: Ze,
+  getSparseSegmentReductionIndicesOutOfRangeErrorMessage: et,
+  getSparseSegmentReductionNegativeSegmentIdsErrorMessage: Xe,
+  getSparseSegmentReductionNonIncreasingSegmentIdsErrorMessage: Ye,
+  getSparseSegmentReductionSegmentIdOutOfRangeErrorMessage: Qe,
+  getUndoAxesPermutation: W,
+  isIdentityPermutation: Be,
+  log: ne,
+  mergeRealAndImagArrays: de,
+  prepareAndValidate: Ee,
+  prepareSplitSize: je,
+  segment_util: rt,
+  shouldFuse: Q,
+  slice_util: se,
+  splitRealAndImagArrays: me,
+  stridesOrDilationsArePositive: ee,
+  tupleValuesAreOne: te,
+  upcastType: re,
+  validateDefaultValueShape: Re,
+  validateInput: ie,
+  validateUpdateShape: ue,
+  warn: oe
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  _e as A,
+  ye as B,
+  Me as C,
+  Te as D,
+  be as E,
+  Ne as F,
+  Pe as G,
+  ze as H,
+  Ce as I,
+  Be as J,
+  Ee as K,
+  nt as L,
+  we as M,
+  je as N,
+  st as O,
+  tt as P,
+  f as R,
+  Se as a,
+  mt as b,
+  Oe as c,
+  Ie as d,
+  at as e,
+  ot as f,
+  $e as g,
+  qe as h,
+  Ge as i,
+  He as j,
+  Ve as k,
+  Ze as l,
+  ke as m,
+  Je as n,
+  Ke as o,
+  Xe as p,
+  Ye as q,
+  Qe as r,
+  et as s,
+  De as t,
+  Le as u,
+  Re as v,
+  xe as w,
+  We as x,
+  ve as y,
+  Ae as z
+};