@genai-fi/nanogpt 0.6.0 → 0.6.1

package/dist/selu_util-4QV_GXTB.js

@@ -0,0 +1,740 @@
+import { k as N, ao as H, q as _, w as S, E as L, ap as te, aq as ne, al as se, an as re, ar as ie, as as oe, at as le, b as ue, au as fe, av as O } from "./index-CamYe_M8.js";
+import { r as ce } from "./reshape-C45vIIRU.js";
+import { s as ae } from "./sum-BpcpxNEh.js";
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Xe(e, t, n, s, r = "NHWC", u) {
+  const i = e[3], o = [...t, i], c = Ae(r);
+  return X(e, o, n, u, s, null, null, c);
+}
+function Be(e, t, n, s, r, u, i = "channelsLast") {
+  const [o, c] = T(t);
+  let a;
+  if (i === "channelsLast")
+    a = [o, c, e[3], e[3]];
+  else if (i === "channelsFirst")
+    a = [o, c, e[1], e[1]];
+  else
+    throw new Error(`Unknown dataFormat ${i}`);
+  return X(e, a, n, s, r, u, !1, i);
+}
+function je(e, t, n, s, r, u, i = "NDHWC") {
+  const [o, c, a] = W(t);
+  let p, g;
+  if (i === "NDHWC")
+    g = "channelsLast", p = [o, c, a, e[4], e[4]];
+  else if (i === "NCDHW")
+    g = "channelsFirst", p = [o, c, a, e[1], e[1]];
+  else
+    throw new Error(`Unknown dataFormat ${i}`);
+  return he(e, p, n, s, r, !1, g, u);
+}
+function X(e, t, n, s, r, u, i = !1, o = "channelsLast") {
+  let [c, a, p, g] = [-1, -1, -1, -1];
+  if (o === "channelsLast")
+    [c, a, p, g] = e;
+  else if (o === "channelsFirst")
+    [c, g, a, p] = e;
+  else
+    throw new Error(`Unknown dataFormat ${o}`);
+  const [l, h, , d] = t, [A, m] = T(n), [b, M] = T(s), f = G(l, b), w = G(h, M), { padInfo: E, outHeight: I, outWidth: x } = de(r, a, p, A, m, f, w, u, o), y = i ? d * g : d;
+  let $;
+  return o === "channelsFirst" ? $ = [c, y, I, x] : o === "channelsLast" && ($ = [c, I, x, y]), {
+    batchSize: c,
+    dataFormat: o,
+    inHeight: a,
+    inWidth: p,
+    inChannels: g,
+    outHeight: I,
+    outWidth: x,
+    outChannels: y,
+    padInfo: E,
+    strideHeight: A,
+    strideWidth: m,
+    filterHeight: l,
+    filterWidth: h,
+    effectiveFilterHeight: f,
+    effectiveFilterWidth: w,
+    dilationHeight: b,
+    dilationWidth: M,
+    inShape: e,
+    outShape: $,
+    filterShape: t
+  };
+}
+function he(e, t, n, s, r, u = !1, i = "channelsLast", o) {
+  let [c, a, p, g, l] = [-1, -1, -1, -1, -1];
+  if (i === "channelsLast")
+    [c, a, p, g, l] = e;
+  else if (i === "channelsFirst")
+    [c, l, a, p, g] = e;
+  else
+    throw new Error(`Unknown dataFormat ${i}`);
+  const [h, d, A, , m] = t, [b, M, f] = W(n), [w, E, I] = W(s), x = G(h, w), y = G(d, E), $ = G(A, I), { padInfo: C, outDepth: k, outHeight: D, outWidth: F } = me(r, a, p, g, b, M, f, x, y, $, o), V = u ? m * l : m;
+  let U;
+  return i === "channelsFirst" ? U = [c, V, k, D, F] : i === "channelsLast" && (U = [c, k, D, F, V]), {
+    batchSize: c,
+    dataFormat: i,
+    inDepth: a,
+    inHeight: p,
+    inWidth: g,
+    inChannels: l,
+    outDepth: k,
+    outHeight: D,
+    outWidth: F,
+    outChannels: V,
+    padInfo: C,
+    strideDepth: b,
+    strideHeight: M,
+    strideWidth: f,
+    filterDepth: h,
+    filterHeight: d,
+    filterWidth: A,
+    effectiveFilterDepth: x,
+    effectiveFilterHeight: y,
+    effectiveFilterWidth: $,
+    dilationDepth: w,
+    dilationHeight: E,
+    dilationWidth: I,
+    inShape: e,
+    outShape: U,
+    filterShape: t
+  };
+}
+function ge(e, t, n, s, r) {
+  s == null && (s = B(e, t, n));
+  const u = e[0], i = e[1], o = R((u - t + 2 * s) / n + 1, r), c = R((i - t + 2 * s) / n + 1, r);
+  return [o, c];
+}
+function pe(e, t, n, s, r, u) {
+  r == null && (r = B(e, t[0], s[0]));
+  const i = [0, 0, 0, n];
+  for (let o = 0; o < 3; o++)
+    e[o] + 2 * r >= t[o] && (i[o] = R((e[o] - t[o] + 2 * r) / s[o] + 1, u));
+  return i;
+}
+function B(e, t, n, s = 1) {
+  const r = G(t, s);
+  return Math.floor((e[0] * (n - 1) - n + r) / 2);
+}
+function T(e) {
+  return typeof e == "number" ? [e, e, e] : e.length === 2 ? [e[0], e[1], 1] : e;
+}
+function W(e) {
+  return typeof e == "number" ? [e, e, e] : e;
+}
+function G(e, t) {
+  return t <= 1 ? e : e + (e - 1) * (t - 1);
+}
+function de(e, t, n, s, r, u, i, o, c) {
+  let a, p, g;
+  if (typeof e == "number") {
+    a = { top: e, bottom: e, left: e, right: e, type: e === 0 ? "VALID" : "NUMBER" };
+    const h = ge([t, n], u, s, e, o);
+    p = h[0], g = h[1];
+  } else if (e === "same") {
+    p = Math.ceil(t / s), g = Math.ceil(n / r);
+    const l = Math.max(0, (p - 1) * s + u - t), h = Math.max(0, (g - 1) * r + i - n), d = Math.floor(l / 2), A = l - d, m = Math.floor(h / 2), b = h - m;
+    a = { top: d, bottom: A, left: m, right: b, type: "SAME" };
+  } else if (e === "valid")
+    a = { top: 0, bottom: 0, left: 0, right: 0, type: "VALID" }, p = Math.ceil((t - u + 1) / s), g = Math.ceil((n - i + 1) / r);
+  else if (typeof e == "object") {
+    const l = c === "channelsLast" ? e[1][0] : e[2][0], h = c === "channelsLast" ? e[1][1] : e[2][1], d = c === "channelsLast" ? e[2][0] : e[3][0], A = c === "channelsLast" ? e[2][1] : e[3][1];
+    a = { top: l, bottom: h, left: d, right: A, type: l === 0 && h === 0 && d === 0 && A === 0 ? "VALID" : "EXPLICIT" }, p = R((t - u + l + h) / s + 1, o), g = R((n - i + d + A) / r + 1, o);
+  } else
+    throw Error(`Unknown padding parameter: ${e}`);
+  return { padInfo: a, outHeight: p, outWidth: g };
+}
+function me(e, t, n, s, r, u, i, o, c, a, p) {
+  let g, l, h, d;
+  if (e === "valid" && (e = 0), typeof e == "number") {
+    g = {
+      top: e,
+      bottom: e,
+      left: e,
+      right: e,
+      front: e,
+      back: e,
+      type: e === 0 ? "VALID" : "NUMBER"
+    };
+    const m = pe([t, n, s, 1], [o, c, a], 1, [r, u, i], e, p);
+    l = m[0], h = m[1], d = m[2];
+  } else if (e === "same") {
+    l = Math.ceil(t / r), h = Math.ceil(n / u), d = Math.ceil(s / i);
+    const A = (l - 1) * r + o - t, m = (h - 1) * u + c - n, b = (d - 1) * i + a - s, M = Math.floor(A / 2), f = A - M, w = Math.floor(m / 2), E = m - w, I = Math.floor(b / 2), x = b - I;
+    g = { top: w, bottom: E, left: I, right: x, front: M, back: f, type: "SAME" };
+  } else
+    throw Error(`Unknown padding parameter: ${e}`);
+  return { padInfo: g, outDepth: l, outHeight: h, outWidth: d };
+}
+function R(e, t) {
+  if (!t)
+    return Math.trunc(e);
+  switch (t) {
+    case "round":
+      return Math.round(e);
+    case "ceil":
+      return Math.ceil(e);
+    case "floor":
+      return Math.floor(e);
+    default:
+      throw new Error(`Unknown roundingMode ${t}`);
+  }
+}
+function P(e) {
+  const [t, n, s] = T(e);
+  return t === 1 && n === 1 && s === 1;
+}
+function qe(e, t) {
+  return P(e) || P(t);
+}
+function Je(e) {
+  return T(e).every((t) => t > 0);
+}
+function Ae(e) {
+  if (e === "NHWC")
+    return "channelsLast";
+  if (e === "NCHW")
+    return "channelsFirst";
+  throw new Error(`Unknown dataFormat ${e}`);
+}
+function Qe(e, t, n) {
+  if (n != null) {
+    if (typeof t == "string")
+      throw Error(`Error in ${e}: pad must be an integer when using dimRoundingMode ${n} but got pad ${t}.`);
+    if (typeof t == "number")
+      N(H(t), () => `Error in ${e}: pad must be an integer when using dimRoundingMode ${n} but got pad ${t}.`);
+    else if (typeof t == "object")
+      t.forEach((s) => {
+        s.forEach((r) => {
+          N(H(r), () => `Error in ${e}: pad must be an integer when using dimRoundingMode ${n} but got pad ${r}.`);
+        });
+      });
+    else
+      throw Error(`Error in ${e}: Unknown padding parameter: ${t}`);
+  }
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function we(e) {
+  const n = { x: S(e, "x", "sigmoid", "float32") };
+  return L.runKernel(te, n);
+}
+const Ee = /* @__PURE__ */ _({ sigmoid_: we });
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function be(e) {
+  const n = { x: S(e, "x", "elu", "float32") };
+  return L.runKernel(ne, n);
+}
+const $e = /* @__PURE__ */ _({ elu_: be });
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Ie(e, t = 0.2) {
+  const s = { x: S(e, "x", "leakyRelu") }, r = { alpha: t };
+  return L.runKernel(se, s, r);
+}
+const xe = /* @__PURE__ */ _({ leakyRelu_: Ie });
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function ye(e, t) {
+  const n = S(e, "x", "prelu"), s = S(t, "alpha", "prelu"), r = { x: n, alpha: s };
+  return L.runKernel(re, r);
+}
+const ke = /* @__PURE__ */ _({ prelu_: ye });
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Me(e) {
+  const n = { x: S(e, "x", "relu") };
+  return L.runKernel(ie, n);
+}
+const Se = /* @__PURE__ */ _({ relu_: Me });
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function De(e) {
+  const n = { x: S(e, "x", "relu6") };
+  return L.runKernel(oe, n);
+}
+const Ne = /* @__PURE__ */ _({ relu6_: De });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function _e(e, t = 0) {
+  const s = { x: S(e, "x", "step") }, r = { alpha: t };
+  return L.runKernel(le, s, r);
+}
+const Le = /* @__PURE__ */ _({ step_: _e });
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Ye(e, t, n) {
+  if (n == null || n === "linear")
+    return e;
+  if (n === "relu")
+    return ue(e, Le(t));
+  throw new Error(`Cannot compute gradient for fused activation ${n}.`);
+}
+function Ze(e, t) {
+  let n = t;
+  const s = fe(e.shape, t.shape);
+  return s.length > 0 && (n = ae(n, s)), ce(n, e.shape);
+}
+function ze(e, t, n, s) {
+  if (t === "linear")
+    return e;
+  if (t === "relu")
+    return Se(e);
+  if (t === "elu")
+    return $e(e);
+  if (t === "relu6")
+    return Ne(e);
+  if (t === "prelu")
+    return ke(e, n);
+  if (t === "leakyrelu")
+    return xe(e, s);
+  if (t === "sigmoid")
+    return Ee(e);
+  throw new Error(`Unknown fused activation ${t}.`);
+}
+const et = (e, t) => !(e > 0) || t === "linear";
+/**
+ * @license
+ * Copyright 2021 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const v = -2, Ce = -1;
+function Ge(e, t, n) {
+  const s = e.shape.length;
+  N(s === t.length, () => `Error in slice${s}D: Length of begin ${t} must match the rank of the array (${s}).`), N(s === n.length, () => `Error in slice${s}D: Length of size ${n} must match the rank of the array (${s}).`);
+  for (let r = 0; r < s; ++r)
+    N(t[r] + n[r] <= e.shape[r], () => `Error in slice${s}D: begin[${r}] + size[${r}] (${t[r] + n[r]}) would overflow input.shape[${r}] (${e.shape[r]})`);
+}
+function Te(e) {
+  const t = [];
+  let n = 0;
+  for (; e > 0; )
+    e & 1 && t.push(n), e /= 2, n++;
+  return t;
+}
+function Re(e, t, n) {
+  const s = [];
+  for (let r = 0; r < e.length; r++)
+    s[r] = Math.ceil((t[r] - e[r]) / n[r]);
+  return s;
+}
+function j(e, t, n, s) {
+  const r = [...e];
+  for (let u = r.length; u < s.length; u++)
+    r.push(1);
+  for (let u = 0; u < n; u++)
+    u === 0 ? r[t] = 1 : (r.splice(
+      t,
+      0,
+      1
+      /* element to add */
+    ), r.pop());
+  return r;
+}
+function q(e, t, n) {
+  return n <= e ? n : n - (t - 1);
+}
+function J(e, t) {
+  const n = [];
+  for (let s = 0; s < e; s++)
+    n.push(t + s);
+  return n;
+}
+function Oe(e, t, n, s, r, u, i, o, c) {
+  const a = e.length;
+  let p = new Array(a), g = new Array(a), l = new Array(a);
+  if (t.length && n > 0) {
+    const h = t[0], d = n + 1;
+    p = Q(i, h, d, s, e), g = Y(o, h, d, r, e), l = j(u, h, d, e);
+  } else
+    for (let h = 0; h < a; h++)
+      p[h] = z(i, s, u, e, h, c), g[h] = ee(o, r, u, e, h, c), l[h] = Z(u, h, c);
+  return {
+    begin: p,
+    end: g,
+    strides: l
+  };
+}
+function Q(e, t, n, s, r) {
+  const u = [...r], i = J(n, t);
+  for (let o = 0; o < u.length; o++)
+    if (i.indexOf(o) > -1)
+      u[o] = 0;
+    else {
+      const c = q(t, n, o);
+      let a = s[c];
+      e & 1 << c && (a = 0), u[o] = a;
+    }
+  return u;
+}
+function Y(e, t, n, s, r) {
+  const u = [...r], i = J(n, t);
+  for (let o = 0; o < u.length; o++)
+    if (i.indexOf(o) > -1)
+      u[o] = Number.MAX_SAFE_INTEGER;
+    else {
+      const c = q(t, n, o);
+      let a = s[c];
+      e & 1 << c && (a = Number.MAX_SAFE_INTEGER), u[o] = a;
+    }
+  for (let o = 0; o < u.length; o++) {
+    const c = r[o];
+    u[o] < 0 && (u[o] += c), u[o] = O(0, u[o], r[o]);
+  }
+  return u;
+}
+function Z(e, t, n) {
+  let s = e[t];
+  return (n & 1 << t || s == null) && (s = 1), s;
+}
+function z(e, t, n, s, r, u) {
+  let i = t[r];
+  const o = n[r] || 1;
+  (e & 1 << r || u & 1 << r || i == null) && (o > 0 ? i = Number.MIN_SAFE_INTEGER : i = Number.MAX_SAFE_INTEGER);
+  const c = s[r];
+  return i < 0 && (i += c), i = O(0, i, c - 1), i;
+}
+function ee(e, t, n, s, r, u) {
+  let i = t[r];
+  const o = n[r] || 1;
+  (e & 1 << r || u & 1 << r || i == null) && (o > 0 ? i = Number.MAX_SAFE_INTEGER : i = Number.MIN_SAFE_INTEGER);
+  const c = s[r];
+  return i < 0 && (i += c), o > 0 ? i = O(0, i, c) : i = O(-1, i, c - 1), i;
+}
+function Fe(e, t, n) {
+  let s = n.length;
+  for (let r = 0; r < n.length; r++)
+    if (n[r] > 1) {
+      s = r;
+      break;
+    }
+  for (let r = s + 1; r < n.length; r++)
+    if (t[r] > 0 || n[r] !== e[r])
+      return !1;
+  return !0;
+}
+function Ve(e, t) {
+  let n = e.length > 0 ? e[e.length - 1] : 1;
+  for (let s = 0; s < e.length - 1; s++)
+    n += e[s] * t[s];
+  return n;
+}
+function Ue(e, t, n) {
+  let s;
+  const r = e.shape.length;
+  typeof t == "number" ? s = [t, ...new Array(r - 1).fill(0)] : t.length < r ? s = t.concat(new Array(r - t.length).fill(0)) : s = t.slice(), s.forEach((i) => {
+    N(i !== -1, () => "slice() does not support negative begin indexing.");
+  });
+  let u;
+  return n == null ? u = new Array(r).fill(-1) : typeof n == "number" ? u = [n, ...new Array(r - 1).fill(-1)] : n.length < r ? u = n.concat(new Array(r - n.length).fill(-1)) : u = n, u = u.map((i, o) => i >= 0 ? i : (N(i === -1, () => `Negative size values should be exactly -1 but got ${i} for the slice() size at index ${o}.`), e.shape[o] - s[o])), [s, u];
+}
+function We(e, t, n, s, r, u, i, o, c) {
+  let a;
+  if (s == null ? (a = new Array(t.length), a.fill(1)) : a = s, i != null && (i & i - 1) !== 0)
+    throw new Error("Multiple ellipses in slice is not allowed.");
+  let p = !1;
+  const g = {
+    dims: a.length,
+    numAddAxisAfterEllipsis: 0,
+    begin: t.slice(),
+    end: n.slice(),
+    strides: a.slice(),
+    beginMask: r,
+    endMask: u,
+    ellipsisMask: i,
+    newAxisMask: o,
+    shrinkAxisMask: c
+  };
+  for (let f = 0; f < g.dims; f++)
+    p && (1 << f & o) !== 0 && g.numAddAxisAfterEllipsis++, 1 << f & i && (p = !0);
+  p || (g.ellipsisMask |= 1 << g.dims, g.dims++);
+  const l = {
+    dims: e.length,
+    beginMask: 0,
+    endMask: 0,
+    beginValid: !1,
+    endValid: !1
+  };
+  ve(g, l);
+  let h = !0, d = !0, A = !0;
+  const m = [], b = [];
+  for (let f = 0; f < e.length; ++f) {
+    if (l.strides[f] === 0)
+      throw Error(`strides[${f}] must be non-zero`);
+    const w = !!(l.shrinkAxisMask & 1 << f), E = e[f];
+    if (E === -1) {
+      m.push(w ? 1 : -1);
+      continue;
+    }
+    const I = [l.beginMask & 1 << f, l.endMask & 1 << f], x = [
+      l.strides[f] > 0 ? 0 : -1,
+      l.strides[f] > 0 ? E : E - 1
+    ];
+    if (w && l.strides[f] <= 0)
+      throw Error("only stride 1 allowed on non-range indexing.");
+    A = A && l.strides[f] === 1;
+    const y = !!(l.beginMask & 1 << f && l.endMask & 1 << f);
+    if (l.beginValid && l.endValid) {
+      if (w) {
+        const D = l.begin[f] < 0 ? E + l.begin[f] : l.begin[f];
+        if (l.begin[f] = D, l.end[f] = l.begin[f] + 1, D < 0 || D >= E)
+          throw Error(`slice index ${l.begin[f]} of dimension ${f} out of bounds.`);
+      } else
+        l.begin[f] = K(l.begin[f], 0, l.strides[f], E, I, x), l.end[f] = K(l.end[f], 1, l.strides[f], E, I, x);
+      const k = l.strides[f] === 1 && l.begin[f] === 0 && l.end[f] === E;
+      h = h && k, d = d && (f === 0 && l.strides[f] === 1 || k);
+    } else
+      h = h && l.strides[f] === 1 && y, d = d && (f === 0 && l.strides[f] === 1 || y);
+    let $, C = !1;
+    if (l.beginValid && l.endValid ? ($ = l.end[f] - l.begin[f], C = !0) : w ? ($ = 1, C = !0) : y && E >= 0 && (l.strides[f] < 0 ? $ = -E : $ = E, C = !0), C) {
+      let k;
+      $ === 0 || $ < 0 != l.strides[f] < 0 ? k = 0 : k = Math.trunc($ / l.strides[f]) + ($ % l.strides[f] !== 0 ? 1 : 0), m.push(k);
+    } else
+      m.push(-1);
+  }
+  for (let f = 0; f < l.finalShapeGatherIndices.length; ++f) {
+    const w = l.finalShapeGatherIndices[f];
+    w >= 0 ? b.push(m[w]) : w === v && b.push(1);
+  }
+  return {
+    finalShapeSparse: b.filter((f, w) => l.finalShapeGatherIndices[w] !== v),
+    finalShape: b,
+    isIdentity: h,
+    sliceDim0: d,
+    isSimpleSlice: A,
+    begin: l.begin,
+    end: l.end,
+    strides: l.strides
+  };
+}
+function ve(e, t) {
+  t.beginMask = 0, t.endMask = 0, t.shrinkAxisMask = 0;
+  let n = 0;
+  t.beginValid = e.begin != null, t.endValid = e.end != null, t.begin = new Array(t.dims), t.end = new Array(t.dims), t.strides = new Array(t.dims), t.finalShapeGatherIndices = [], t.finalShapeGatherIndicesSparse = [], t.inputShapeGatherIndicesSparse = new Array(t.dims);
+  for (let s = 0; s < e.dims; s++)
+    if (1 << s & e.ellipsisMask) {
+      const r = Math.min(t.dims - (e.dims - s) + 1 + e.numAddAxisAfterEllipsis, t.dims);
+      for (; n < r; n++)
+        t.begin[n] = 0, t.end[n] = 0, t.strides[n] = 1, t.beginMask |= 1 << n, t.endMask |= 1 << n, t.finalShapeGatherIndices.push(n), t.finalShapeGatherIndicesSparse.push(-1), t.inputShapeGatherIndicesSparse[n] = s;
+    } else if (1 << s & e.newAxisMask)
+      t.finalShapeGatherIndices.push(v), t.finalShapeGatherIndicesSparse.push(-1);
+    else {
+      if (n === t.begin.length)
+        throw Error(`Index out of range using input dim ${n}; input has only ${t.dims} dims, ${t.begin.length}.`);
+      e.begin != null && (t.begin[n] = e.begin[s]), e.end != null && (t.end[n] = e.end[s]), t.strides[n] = e.strides[s], e.beginMask & 1 << s && (t.beginMask |= 1 << n), e.endMask & 1 << s && (t.endMask |= 1 << n), e.shrinkAxisMask & 1 << s ? (t.finalShapeGatherIndices.push(Ce), t.finalShapeGatherIndicesSparse.push(-1), t.shrinkAxisMask |= 1 << n) : (t.finalShapeGatherIndices.push(n), t.finalShapeGatherIndicesSparse.push(s)), t.inputShapeGatherIndicesSparse[n] = s, n++;
+    }
+}
+function K(e, t, n, s, r, u) {
+  if (r[t])
+    return n > 0 ? u[t] : u[t + 1 & 1];
+  {
+    const i = e < 0 ? s + e : e;
+    return i < u[0] ? u[0] : i > u[1] ? u[1] : i;
+  }
+}
+const tt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  assertParamsValid: Ge,
+  computeFlatOffset: Ve,
+  computeOutShape: Re,
+  getNormalizedAxes: Oe,
+  isSliceContinous: Fe,
+  maskToAxes: Te,
+  parseSliceParams: Ue,
+  sliceInfo: We,
+  startForAxis: z,
+  startIndicesWithElidedDims: Q,
+  stopForAxis: ee,
+  stopIndicesWithElidedDims: Y,
+  stridesForAxis: Z,
+  stridesWithElidedDims: j
+}, Symbol.toStringTag, { value: "Module" }));
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const nt = 1.7580993408473768, st = 1.0507009873554805;
+export {
+  ke as A,
+  Ne as B,
+  We as C,
+  Re as D,
+  st as S,
+  nt as a,
+  ze as b,
+  Qe as c,
+  X as d,
+  he as e,
+  B as f,
+  Xe as g,
+  Be as h,
+  je as i,
+  Ae as j,
+  qe as k,
+  Ze as l,
+  Ye as m,
+  tt as n,
+  Je as o,
+  Ue as p,
+  Ge as q,
+  Fe as r,
+  et as s,
+  P as t,
+  Ve as u,
+  Le as v,
+  Ee as w,
+  $e as x,
+  Se as y,
+  xe as z
+};