@genai-fi/nanogpt 0.9.1 → 0.10.1

package/dist/binary_op_util-pKXltfxI.js

@@ -0,0 +1,192 @@
+var t;
+(function(e) {
+  e[e.ADD = 0] = "ADD", e[e.ATAN2 = 1] = "ATAN2", e[e.COMPLEX_MULTIPLY_IMAG = 2] = "COMPLEX_MULTIPLY_IMAG", e[e.COMPLEX_MULTIPLY_REAL = 3] = "COMPLEX_MULTIPLY_REAL", e[e.DIV = 4] = "DIV", e[e.ELU_DER = 5] = "ELU_DER", e[e.EQUAL = 6] = "EQUAL", e[e.FLOOR_DIV = 7] = "FLOOR_DIV", e[e.GREATER = 8] = "GREATER", e[e.GREATER_EQUAL = 9] = "GREATER_EQUAL", e[e.LESS = 10] = "LESS", e[e.LESS_EQUAL = 11] = "LESS_EQUAL", e[e.LOGICAL_AND = 12] = "LOGICAL_AND", e[e.LOGICAL_OR = 13] = "LOGICAL_OR", e[e.MAX = 14] = "MAX", e[e.MIN = 15] = "MIN", e[e.MOD = 16] = "MOD", e[e.MUL = 17] = "MUL", e[e.NOT_EQUAL = 18] = "NOT_EQUAL", e[e.POW = 19] = "POW", e[e.PRELU = 20] = "PRELU", e[e.SQUARED_DIFFERENCE = 21] = "SQUARED_DIFFERENCE", e[e.SUB = 22] = "SUB";
+})(t || (t = {}));
+const r = "let resultTemp = a + b;", L = "let resultTemp = atan2(a, b);", E = "let resultTemp = areal * breal - aimag * bimag;", c = "let resultTemp = areal * bimag + aimag * breal;", u = "let resultTemp = a / b;", n = "let resultTemp = select(a * (b + 1.0), a, b >= b - b);", A = `
+  let zero = sign(a) * 0 + 0;
+  let one = sign(b) * 0 + 1;
+  let resultTemp = select(zero, one, a == b);
+`, N = `
+  let remainder =
+      select(a % b, round(a % b), (round(a) == a) & (round(b) == b));
+  let quotient = (a - remainder) / b;
+  let resultTemp =
+      round(select(quotient, quotient - 1, sign(remainder) == -sign(b)));
+`, _ = `
+  let zero = sign(a) * 0 + 0;
+  let one = sign(b) * 0 + 1;
+  let resultTemp = select(zero, one, a > b);
+`, m = `
+  let zero = sign(a) * 0 + 0;
+  let one = sign(b) * 0 + 1;
+  let resultTemp = select(zero, one, a >= b);
+`, R = `
+  let zero = sign(a) * 0 + 0;
+  let one = sign(b) * 0 + 1;
+  let resultTemp = select(zero, one, a < b);
+`, U = `
+  let zero = sign(a) * 0 + 0;
+  let one = sign(b) * 0 + 1;
+  let resultTemp = select(zero, one, a <= b);
+`, I = "return f32(a >= 1.0 && b >= 1.0);", f = `return (vec4<f32>(a >= vec4<f32>(1.0)) *
+  vec4<f32>(b >= vec4<f32>(1.0)));`, M = "return f32(a >= 1.0 || b >= 1.0);", i = `return min(vec4<f32>(a >= vec4<f32>(1.0)) +
+  vec4<f32>(b >= vec4<f32>(1.0)), vec4<f32>(1.0));`, D = "let resultTemp = max(a, b);", v = "let resultTemp = min(a, b);", P = `
+  let isNaN = b == 0.;
+  var resultTemp = a % b;
+  resultTemp = select((resultTemp + b) % b, resultTemp,
+      (a < 0. && b < 0.) || (a >= 0. && b > 0.));
+`, g = `
+  let isNaN = !vec4<bool>(b);
+  var resultTemp = vec4<f32>(a % b);
+  if (!((a[0] < 0. && b[0] < 0.) || (a[0] >= 0. && b[0] > 0.))) {
+    resultTemp[0] = (resultTemp[0] + b[0]) % b[0];
+  }
+  if (!((a[1] < 0. && b[1] < 0.) || (a[1] >= 0. && b[1] > 0.))) {
+    resultTemp[1] = (resultTemp[1] + b[1]) % b[1];
+  }
+  if (!((a[2] < 0. && b[2] < 0.) || (a[2] >= 0. && b[2] > 0.))) {
+    resultTemp[2] = (resultTemp[2] + b[2]) % b[2];
+  }
+  if (!((a[3] < 0. && b[3] < 0.) || (a[3] >= 0. && b[3] > 0.))) {
+    resultTemp[3] = (resultTemp[3] + b[3]) % b[3];
+  }
+`, C = "let resultTemp = a * b;", S = `
+  var resultTemp = f32(a != b);
+  let valueForNaN = 1.0;
+`, d = `
+  var resultTemp = vec4<f32>(a != b);
+  let valueForNaN = 1.0;
+`, T = `
+  let isNaN = a < 0.0 && floor(b) < b;
+  if (b == 0.0) {
+    return 1.0;
+  }
+  var resultTemp = select(sign(a) * pow(abs(a), b), pow(abs(a), b),
+      round(abs(b) % 2.0) != 1.0);
+`, G = `
+  let isModRound1Bool = vec4<i32>(round(abs(b) % vec4<f32>(2.0))) == vec4<i32>(1);
+  let isModRound1 = vec4<f32>(isModRound1Bool);
+  let multiplier = sign(a) * isModRound1 + (vec4<f32>(1.0) - isModRound1);
+  var resultTemp = multiplier * pow(abs(a), b);
+
+  // Ensure that a^0 = 1, including 0^0 = 1 as this correspond to TF and JS
+  let isExpZero = b == vec4<f32>(0.0);
+  if (isExpZero.r) {
+    resultTemp.r = 1.0;
+  }
+  if (isExpZero.g) {
+    resultTemp.g = 1.0;
+  }
+  if (isExpZero.b) {
+    resultTemp.b = 1.0;
+  }
+  if (isExpZero.a) {
+    resultTemp.a = 1.0;
+  }
+  let isNaN = (a < vec4<f32>(0.0)) & (floor(b) < b);
+`, Q = "if (a < 0.0) { return b * a; }  return a;", k = `
+  let aLessThanZero = vec4<f32>(a < vec4<f32>(0.0));
+  return (aLessThanZero * (b * a)) + ((vec4<f32>(1.0) - aLessThanZero) * a);
+`, F = "let resultTemp = (a - b) * (a - b);", z = "let resultTemp = a - b;";
+function X(e, a) {
+  let s;
+  do {
+    switch (e) {
+      case t.ATAN2:
+        s = L;
+        break;
+      case t.MAX:
+        s = D;
+        break;
+      case t.MIN:
+        s = v;
+        break;
+      case t.MOD:
+        s = a ? g : P;
+        break;
+      case t.NOT_EQUAL:
+        s = a ? d : S;
+        break;
+      case t.POW:
+        s = a ? G : T;
+        break;
+      default:
+        continue;
+    }
+    let o, l, b;
+    return a ? (o = "isnanVec4", l = "vec4<f32>", b = "vec4<bool>") : (o = "isnan", l = "f32", b = "bool"), `
+      let aIsNaN = ${o}(a);
+      let aPostLegalization = select(a, ${l}(42), aIsNaN);
+      let bIsNaN = ${o}(b);
+      let bPostLegalization = select(b, ${l}(42), bIsNaN);
+      let isNaN = false;
+      let valueForNaN = uniforms.NAN;
+      {
+        let a = aPostLegalization;
+        let b = bPostLegalization;
+        ${s}
+        return select(
+            resultTemp, ${l}(valueForNaN),
+            ${b}(isNaN) | aIsNaN | bIsNaN);
+      }
+    `;
+  } while (!1);
+  switch (e) {
+    case t.ADD:
+      s = r;
+      break;
+    case t.COMPLEX_MULTIPLY_IMAG:
+      s = c;
+      break;
+    case t.COMPLEX_MULTIPLY_REAL:
+      s = E;
+      break;
+    case t.DIV:
+      s = u;
+      break;
+    case t.ELU_DER:
+      s = n;
+      break;
+    case t.EQUAL:
+      s = A;
+      break;
+    case t.FLOOR_DIV:
+      s = N;
+      break;
+    case t.GREATER:
+      s = _;
+      break;
+    case t.GREATER_EQUAL:
+      s = m;
+      break;
+    case t.LESS:
+      s = R;
+      break;
+    case t.LESS_EQUAL:
+      s = U;
+      break;
+    case t.LOGICAL_AND:
+      return a ? f : I;
+    case t.LOGICAL_OR:
+      return a ? i : M;
+    case t.MUL:
+      s = C;
+      break;
+    case t.PRELU:
+      return a ? k : Q;
+    case t.SQUARED_DIFFERENCE:
+      s = F;
+      break;
+    case t.SUB:
+      s = z;
+      break;
+  }
+  return `
+    ${s}
+    return resultTemp;
+  `;
+}
+export {
+  t as B,
+  X as g
+};

package/dist/broadcast_to-CwF7XIeu.js

@@ -0,0 +1,30 @@
+import { A as f, B as h, D as p, E as m } from "./index-ZyQhjEPo.js";
+import { T as g } from "./tensor_util-DV-FP5Q3.js";
+import { d as u } from "./tensor-DdQUJZlz.js";
+import { r as T } from "./reshape-DevtBWtf.js";
+function b(e, o) {
+  let r = h(e, "broadcastTo", "x");
+  const a = r.shape;
+  if (u(o), o.length < r.rank)
+    throw new Error(`broadcastTo(): shape.length=${o.length} < input.rank=${r.rank}.`);
+  if (o.length > r.rank) {
+    const t = r.shape.slice();
+    for (; t.length < o.length; )
+      t.unshift(1);
+    r = T(r, t);
+  }
+  const s = r.shape, n = Array.from(o);
+  for (let t = o.length - 1; t >= 0; t--)
+    if (s[t] === o[t])
+      n[t] = 1;
+    else if (r.shape[t] !== 1)
+      throw new Error(`broadcastTo(): [${a}] cannot be broadcast to [${o}].`);
+  if (n.map((t, l) => t > 1 ? l : -1).filter((t) => t >= 0).length === 0)
+    return p(r);
+  const i = { x: r }, c = { reps: n };
+  return m.runKernel(g, i, c);
+}
+const N = /* @__PURE__ */ f({ broadcastTo_: b });
+export {
+  N as b
+};

package/dist/checks/appendCache.js

@@ -1,5 +1,5 @@
-import { s, e as a } from "../index-BzFyqcy-.js";
-import { t } from "../tensor4d-Df1WlVDY.js";
+import { s, e as a } from "../index-ZyQhjEPo.js";
+import { t } from "../tensor4d-B8roDgtc.js";
 async function u(e) {
   await s(e);
   const n = t(

package/dist/checks/attentionMask.js

@@ -1,6 +1,6 @@
-import { s as i, e } from "../index-BzFyqcy-.js";
-import { t } from "../tensor4d-Df1WlVDY.js";
-import { t as a } from "../tensor2d-D76QGjF3.js";
+import { s as i, e } from "../index-ZyQhjEPo.js";
+import { t } from "../tensor4d-B8roDgtc.js";
+import { t as a } from "../tensor2d-G4Ys2GxX.js";
 async function k(n) {
   await i(n);
   const s = t(

package/dist/checks/check.d.ts

@@ -5,5 +5,5 @@ interface Result {
     passed: boolean;
     maxError?: number;
 }
-export default function runCheck(check: (backend: string) => Promise<unknown>, epsilon?: number): Promise<Result[]>;
+export default function runCheck(check: (backend: string) => Promise<unknown>, epsilon?: number, backends?: string[]): Promise<Result[]>;
 export {};

package/dist/checks/check.js

@@ -1,20 +1,20 @@
-import { arraysClose as l } from "../utilities/arrayClose.js";
-async function f(c, a) {
-  const n = ["cpu", "webgl", "webgpu"], t = [];
-  for (const e of n)
+import { arraysClose as p } from "../utilities/arrayClose.js";
+async function d(c, o, n) {
+  const u = n ?? ["cpu", "webgl", "webgpu"], t = [];
+  for (const e of u)
     try {
       const r = await c(e);
       t.push({ backend: e, result: r, passed: !0 });
     } catch (r) {
       t.push({ backend: e, error: r.message, result: [], passed: !1 });
     }
-  const s = await Promise.all(t), u = s[0].result;
+  const s = await Promise.all(t), l = s[0].result;
   for (let e = 1; e < s.length; e++) {
-    const r = s[e].result, o = l(u, r);
-    s[e].passed = o <= (a ?? 1e-6), s[e].maxError = o;
+    const r = s[e].result, a = p(l, r);
+    s[e].passed = a <= (o ?? 1e-6), s[e].maxError = a;
   }
   return s;
 }
 export {
-  f as default
+  d as default
 };

package/dist/checks/gelu.js

@@ -1,5 +1,5 @@
-import { s as e, e as o } from "../index-BzFyqcy-.js";
-import { t as s } from "../tensor2d-D76QGjF3.js";
+import { s as e, e as o } from "../index-ZyQhjEPo.js";
+import { t as s } from "../tensor2d-G4Ys2GxX.js";
 async function m(t) {
   await e(t);
   const r = s(

package/dist/checks/index.d.ts

@@ -6,6 +6,7 @@ import { execute as normRMSGrad } from './normRMSGrad';
 import { execute as appendCache } from './appendCache';
 import { execute as attentionMask } from './attentionMask';
 import { execute as matMulGelu } from './matMulGelu';
+import { execute as packUnpack } from './packUnpack';
 import { default as runCheck } from './check';
 import { createWeightStatistics, createTensorStatistics } from './weights';
 declare const checks: {
@@ -17,6 +18,7 @@ declare const checks: {
     appendCache: typeof appendCache;
     attentionMask: typeof attentionMask;
     matMulGelu: typeof matMulGelu;
+    packUnpack: typeof packUnpack;
     runCheck: typeof runCheck;
     createLayerWeightStatistics: typeof createWeightStatistics;
     createWeightStatistics: typeof createTensorStatistics;

package/dist/checks/index.js

@@ -6,9 +6,10 @@ import { execute as o } from "./normRMSGrad.js";
 import { execute as a } from "./appendCache.js";
 import { execute as m } from "./attentionMask.js";
 import { execute as i } from "./matMulGelu.js";
+import { execute as u } from "./packUnpack.js";
 import s from "./check.js";
-import { createTensorStatistics as u, createWeightStatistics as x } from "./weights.js";
-const d = {
+import { createTensorStatistics as x, createWeightStatistics as p } from "./weights.js";
+const C = {
   rope: e,
   qkv: r,
   gelu: c,
@@ -17,10 +18,11 @@ const d = {
   appendCache: a,
   attentionMask: m,
   matMulGelu: i,
+  packUnpack: u,
   runCheck: s,
-  createLayerWeightStatistics: x,
-  createWeightStatistics: u
+  createLayerWeightStatistics: p,
+  createWeightStatistics: x
 };
 export {
-  d as default
+  C as default
 };

package/dist/checks/matMulGelu.js

@@ -1,9 +1,9 @@
-import { s as n, e as s } from "../index-BzFyqcy-.js";
-import "../random_width-CXVRloNK.js";
-import "../register_all_kernels-DIGpEwcf.js";
-import "../index-Tf7vU29b.js";
-import "../dataset-DlZtKmBq.js";
-import { t as e } from "../tensor2d-D76QGjF3.js";
+import { s as n, e as s } from "../index-ZyQhjEPo.js";
+import "../random_width-DY6Kk2Dl.js";
+import "../register_all_kernels-Bwu1PTuU.js";
+import "../index-Cp39cXWe.js";
+import "../dataset-0xP8GjwI.js";
+import { t as e } from "../tensor2d-G4Ys2GxX.js";
 async function f(t) {
   await n(t);
   const r = e(

package/dist/checks/normRMS.js

@@ -1,13 +1,13 @@
-import { s as u, y as A, e as y } from "../index-BzFyqcy-.js";
-import { a as h } from "../ops-LuCMAnmM.js";
-import { t as p } from "../tensor1d-vML0r3q6.js";
-import { t as a } from "../tensor-CZr4dh61.js";
+import { s as i, u as A, e as y } from "../index-ZyQhjEPo.js";
+import { a as h } from "../ops-CNI3TwqM.js";
+import { t as p } from "../tensor1d-CeZuc-Rv.js";
+import { t as a } from "../tensor-f35l8Odg.js";
 const w = Array.from({ length: 2048 * 192 }, () => Math.random()), x = Array.from({ length: 192 }, () => Math.random()), M = Array.from({ length: 2048 * 192 }, () => Math.random());
 async function k(t) {
-  await u(t);
+  await i(t);
   const o = p(x, "float32"), n = a(w, [16, 128, 192], "float32"), s = a(M, [16, 128, 192], "float32"), e = (d, g) => {
-    const i = y().runKernel("RMSNorm", { x: d, gamma: g });
-    return h.meanSquaredError(i, s);
+    const u = y().runKernel("RMSNorm", { x: d, gamma: g });
+    return h.meanSquaredError(u, s);
   }, { value: m, grads: r } = A(e)([n, o]), c = await m.array(), f = await r[0].array(), l = await r[1].array();
   return [c, f, l];
 }

package/dist/checks/normRMSGrad.js

@@ -1,6 +1,6 @@
-import { s as c, e as d } from "../index-BzFyqcy-.js";
-import { t as f } from "../tensor1d-vML0r3q6.js";
-import { t as r } from "../tensor-CZr4dh61.js";
+import { s as c, e as d } from "../index-ZyQhjEPo.js";
+import { t as f } from "../tensor1d-CeZuc-Rv.js";
+import { t as r } from "../tensor-f35l8Odg.js";
 const y = Array.from({ length: 2048 * 192 }, () => Math.random()), i = Array.from({ length: 192 }, () => Math.random()), l = Array.from({ length: 2048 * 192 }, () => Math.random());
 async function x(t) {
   await c(t);

package/dist/checks/packUnpack.d.ts

@@ -0,0 +1 @@
+export declare function execute(backend: string): Promise<number | number[] | number[][] | number[][][] | number[][][][] | number[][][][][] | number[][][][][][]>;

package/dist/checks/packUnpack.js

@@ -0,0 +1,18 @@
+import { s as a, e } from "../index-ZyQhjEPo.js";
+import { t as c } from "../tensor2d-G4Ys2GxX.js";
+async function i(n) {
+  await a(n);
+  const r = c(
+    [
+      [0.1, 0.2, 0, 0, 1230, 1232331234, -12234234],
+      [0.1, 0.2, 0, 0, -1230, -1232331234, 12234234],
+      [0, 0, 0, 0, -1, 0, 0],
+      [0, 0, 0, 0, -0.1, 1e-3, 0]
+    ],
+    [4, 7]
+  ), t = e().runKernel("Pack16", { x: r });
+  return await e().runKernel("Unpack16", { x: t }).array();
+}
+export {
+  i as execute
+};

package/dist/checks/qkv.js

@@ -1,34 +1,19 @@
-import { B as i, C as u, D as c, s as l, e as h } from "../index-BzFyqcy-.js";
-import { t as f } from "../tensor2d-D76QGjF3.js";
-/**
- * @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 m(t, e, n) {
-  if (i(t), e != null && e.length !== 3)
+import { x as i, y as u, s as c, e as l } from "../index-ZyQhjEPo.js";
+import { c as m } from "../tensor-DdQUJZlz.js";
+import { t as f } from "../tensor2d-G4Ys2GxX.js";
+function h(t, e, n) {
+  if (m(t), e != null && e.length !== 3)
     throw new Error("tensor3d() requires shape to have three numbers");
-  const r = u(t, n);
+  const r = i(t, n);
   if (r.length !== 3 && r.length !== 1)
     throw new Error("tensor3d() requires values to be number[][][] or flat/TypedArray");
   if (r.length === 1 && e == null)
     throw new Error("tensor3d() requires shape to be provided when `values` are a flat array");
-  return c(t, e, r, n);
+  return u(t, e, r, n);
 }
-async function y(t) {
-  await l(t);
-  const e = m(
+async function p(t) {
+  await c(t);
+  const e = h(
     [
       [
         [0.1, 0.2],
@@ -42,9 +27,9 @@ async function y(t) {
       [0.7, 0.8, 1.1, 1.2, 1.5, 1.6]
     ],
     [2, 6]
-  ), r = h().runKernel("QKV", { x: e, kernel: n }, { heads: 1 }), o = await r[0].array(), a = await r[1].array(), s = await r[2].array();
+  ), r = l().runKernel("QKV", { x: e, kernel: n }, { heads: 1 }), o = await r[0].array(), a = await r[1].array(), s = await r[2].array();
   return [o, a, s];
 }
 export {
-  y as execute
+  p as execute
 };

package/dist/checks/rope.js

@@ -1,6 +1,6 @@
 import t from "../layers/RoPECache.js";
-import { s as c, e as i } from "../index-BzFyqcy-.js";
-import { t as p } from "../tensor4d-Df1WlVDY.js";
+import { s as c, e as i } from "../index-ZyQhjEPo.js";
+import { t as p } from "../tensor4d-B8roDgtc.js";
 async function y(a) {
   await c(a);
   const o = p(

package/dist/checks/weights.js

@@ -1,29 +1,31 @@
-async function d(s) {
+async function b(s) {
+  if (!Array.isArray(s) && s.dtype !== "float32")
+    throw new Error(`Unsupported dtype ${s.dtype} for weight statistics.`);
   const e = Array.isArray(s) ? s : await s.data(), a = e.length;
-  let n = 0, l = 0, i = e[0], r = e[0], u = 0, h = !0, f = !1, m = 0;
+  let r = 0, l = 0, n = e[0], i = e[0], f = 0, d = !0, u = !1, y = 0;
   for (let c = 0; c < a; c++) {
     const t = e[c];
-    n += t, l += t * t, t < i && (i = t), t > r && (r = t), t === 0 && u++, Math.abs(t) < 1e-8 && m++, Number.isNaN(t) && (f = !0);
+    r += t, l += t * t, t < n && (n = t), t > i && (i = t), t === 0 && f++, Math.abs(t) < 1e-8 && y++, Number.isNaN(t) && (u = !0);
   }
-  const o = n / a, y = l / a - o * o, N = Math.sqrt(y), b = u / a;
+  const o = r / a, m = l / a - o * o, p = Math.sqrt(m), N = f / a;
   return {
     mean: o,
-    std: N,
-    min: i,
-    max: r,
-    sparsity: b,
-    isFinite: h,
-    hasNaN: f,
-    closeToZeroCount: m
+    std: p,
+    min: n,
+    max: i,
+    sparsity: N,
+    isFinite: d,
+    hasNaN: u,
+    closeToZeroCount: y
   };
 }
-async function S(s) {
+async function h(s) {
   const e = s.trainableVariables, a = {};
-  for (const n of e)
-    a[n.name] = await d(n);
+  for (const r of e)
+    a[r.name] = await b(r);
   return a;
 }
 export {
-  d as createTensorStatistics,
-  S as createWeightStatistics
+  b as createTensorStatistics,
+  h as createWeightStatistics
 };

package/dist/complex-CSlYz-2T.js

@@ -0,0 +1,13 @@
+import { A as r, B as o, E as t } from "./index-ZyQhjEPo.js";
+import { h as c } from "./tensor_util-DV-FP5Q3.js";
+import { j as n } from "./tensor-DdQUJZlz.js";
+function l(s, m) {
+  const a = o(s, "real", "complex"), e = o(m, "imag", "complex");
+  n(a.shape, e.shape, `real and imag shapes, ${a.shape} and ${e.shape}, must match in call to tf.complex().`);
+  const p = { real: a, imag: e };
+  return t.runKernel(c, p);
+}
+const f = /* @__PURE__ */ r({ complex_: l });
+export {
+  f as c
+};

package/dist/complex_util-Yc1A_gV1.js

@@ -0,0 +1,55 @@
+function s(t, a) {
+  if (t.length !== a.length)
+    throw new Error(`Cannot merge real and imag arrays of different lengths. real:${t.length}, imag: ${a.length}.`);
+  const r = new Float32Array(t.length * 2);
+  for (let n = 0; n < r.length; n += 2)
+    r[n] = t[n / 2], r[n + 1] = a[n / 2];
+  return r;
+}
+function l(t) {
+  const a = new Float32Array(t.length / 2), r = new Float32Array(t.length / 2);
+  for (let n = 0; n < t.length; n += 2)
+    a[n / 2] = t[n], r[n / 2] = t[n + 1];
+  return { real: a, imag: r };
+}
+function h(t) {
+  const a = Math.ceil(t.length / 4), r = new Float32Array(a), n = new Float32Array(a);
+  for (let e = 0; e < t.length; e += 4)
+    r[Math.floor(e / 4)] = t[e], n[Math.floor(e / 4)] = t[e + 1];
+  return { real: r, imag: n };
+}
+function i(t) {
+  const a = Math.floor(t.length / 4), r = new Float32Array(a), n = new Float32Array(a);
+  for (let e = 2; e < t.length; e += 4)
+    r[Math.floor(e / 4)] = t[e], n[Math.floor(e / 4)] = t[e + 1];
+  return { real: r, imag: n };
+}
+function g(t, a) {
+  const r = t[a * 2], n = t[a * 2 + 1];
+  return { real: r, imag: n };
+}
+function f(t, a, r, n) {
+  t[n * 2] = a, t[n * 2 + 1] = r;
+}
+function c(t, a) {
+  const r = new Float32Array(t / 2), n = new Float32Array(t / 2);
+  for (let e = 0; e < Math.ceil(t / 2); e++) {
+    const o = (a ? 2 : -2) * Math.PI * (e / t);
+    r[e] = Math.cos(o), n[e] = Math.sin(o);
+  }
+  return { real: r, imag: n };
+}
+function u(t, a, r) {
+  const n = (r ? 2 : -2) * Math.PI * (t / a), e = Math.cos(n), o = Math.sin(n);
+  return { real: e, imag: o };
+}
+export {
+  f as a,
+  i as b,
+  h as c,
+  c as d,
+  u as e,
+  g,
+  s as m,
+  l as s
+};

package/dist/concat-BHlIJeyT.js

@@ -0,0 +1,19 @@
+import { A as c, C as s, D as p, E as i } from "./index-ZyQhjEPo.js";
+import { C as m } from "./tensor_util-DV-FP5Q3.js";
+import { a as f } from "./tensor-DdQUJZlz.js";
+function l(o, r = 0) {
+  f(o.length >= 1, () => "Pass at least one tensor to concat");
+  const t = s(o, "tensors", "concat", "string_or_numeric");
+  if (t[0].dtype === "complex64" && t.forEach((n) => {
+    if (n.dtype !== "complex64")
+      throw new Error(`Cannot concatenate complex64 tensors with a tensor
+          with dtype ${n.dtype}. `);
+  }), t.length === 1)
+    return p(t[0]);
+  const e = t, a = { axis: r };
+  return i.runKernel(m, e, a);
+}
+const E = /* @__PURE__ */ c({ concat_: l });
+export {
+  E as c
+};

package/dist/concat_util-DcJk7YHS.js

@@ -0,0 +1,22 @@
+import { a as s } from "./tensor-DdQUJZlz.js";
+function h(n, o) {
+  const t = n[0].length;
+  n.forEach((a, c) => {
+    s(a.length === t, () => `Error in concat${t}D: rank of tensors[${c}] must be the same as the rank of the rest (${t})`);
+  }), s(o >= 0 && o < t, () => `Error in concat${t}D: axis must be between 0 and ${t - 1}.`);
+  const e = n[0];
+  n.forEach((a, c) => {
+    for (let r = 0; r < t; r++)
+      s(r === o || a[r] === e[r], () => `Error in concat${t}D: Shape of tensors[${c}] (${a}) does not match the shape of the rest (${e}) along the non-concatenated axis ${c}.`);
+  });
+}
+function $(n, o) {
+  const t = n[0].slice();
+  for (let e = 1; e < n.length; e++)
+    t[o] += n[e][o];
+  return t;
+}
+export {
+  h as a,
+  $ as c
+};

package/dist/data/docx.js

@@ -1,4 +1,4 @@
-import { j as a } from "../jszip.min-CjP2V1VV.js";
+import { j as a } from "../jszip.min-Bz5-11Bk.js";
 async function c(n) {
   const t = await (await a.loadAsync(n)).file("word/document.xml")?.async("string");
   if (!t) throw new Error("Failed to load document.xml");

package/dist/data/parquet.js

@@ -1,7 +1,7 @@
-import { B as n } from "../index-Tf7vU29b.js";
+import { B as n } from "../index-Cp39cXWe.js";
 const p = 100 * 1024 * 1024;
 async function d(i, s = p, e = "text") {
-  const r = await (await import("../parquet-C0Tlmv9c.js").then((t) => t.p)).ParquetReader.openBuffer(n.from(await i.arrayBuffer())), a = [], f = r.getCursor([[e]]);
+  const r = await (await import("../parquet-BE8MU_ge.js").then((t) => t.p)).ParquetReader.openBuffer(n.from(await i.arrayBuffer())), a = [], f = r.getCursor([[e]]);
   let o = 0;
   for (; ; ) {
     const t = await f.next();