@genai-fi/nanogpt 0.19.1 → 0.20.1

package/dist/webgpu_program-WOyIVMlZ.js

@@ -0,0 +1,392 @@
+import { Ln as e, Ms as t, Ns as n, Ps as r, Rs as i } from "./dist-BewPQWjc.js";
+//#region node_modules/@tensorflow/tfjs-backend-webgpu/dist/shader_util.js
+function a(e, t) {
+	if (Math.max(...e) > 5) throw Error("Cannot symbolically compute strides for rank > 6 tensor.");
+	let n = e.length, r = e.map((e) => `${t}.${"xyzwuv"[e]}`), i = Array(n - 1);
+	i[n - 2] = r[n - 1];
+	for (let e = n - 3; e >= 0; --e) i[e] = `(${i[e + 1]} * ${r[e + 1]})`;
+	return i;
+}
+var o = (e, t, n) => n === "int32" ? `atomicAdd(${e}, bitcast<i32>(${t}));` : `
+          {
+            var oldValue = 0;
+            loop {
+              let newValueF32 = bitcast<f32>(oldValue) + (${t});
+              let newValue = bitcast<i32>(newValueF32);
+              let res = atomicCompareExchangeWeak(${e}, oldValue, newValue);
+              if res.exchanged {
+                break;
+              }
+              oldValue = res.old_value;
+            }
+          }`, s;
+(function(e) {
+	e[e.FROM_PIXELS = 0] = "FROM_PIXELS", e[e.DRAW = 1] = "DRAW";
+})(s ||= {});
+var c = (e, n, r, i, a) => {
+	let o = h(r, {
+		dtype: i.dtype,
+		shape: i.shape
+	}, n), s = e.createShaderModule({
+		code: o,
+		label: n.constructor.name
+	}), c = t().get("WEBGPU_PRINT_SHADER");
+	if (c !== "") {
+		c = c.toLowerCase();
+		let e = c.split(",");
+		(c === "all" || e.some((e) => n.shaderKey.toLowerCase().includes(e))) && (console.group(n.shaderKey), console.debug(o), console.groupEnd());
+	}
+	return a ? e.createComputePipelineAsync({
+		compute: {
+			module: s,
+			entryPoint: "_start"
+		},
+		label: n.constructor.name,
+		layout: "auto"
+	}) : e.createComputePipeline({
+		compute: {
+			module: s,
+			entryPoint: "_start"
+		},
+		label: n.constructor.name,
+		layout: "auto"
+	});
+}, l = (e, t = "f32") => {
+	switch (e) {
+		case 1: return `${t}`;
+		case 2: return `vec2<${t}>`;
+		case 3: return `vec3<${t}>`;
+		case 4: return `vec4<${t}>`;
+		default: throw Error(`${e}-component ${t} is not supported.`);
+	}
+};
+function u(e) {
+	if (e <= 1) return "i32";
+	if (e === 2) return "vec2<i32>";
+	if (e === 3) return "vec3<i32>";
+	if (e === 4) return "vec4<i32>";
+	if (e === 5) return "vec5";
+	if (e === 6) return "vec6";
+	throw Error(`GPU for rank ${e} is not yet supported`);
+}
+function d(e) {
+	if (e === 0) return "x";
+	if (e === 1) return "y";
+	if (e === 2) return "z";
+	if (e === 3) return "w";
+	if (e === 4) return "u";
+	if (e === 5) return "v";
+	throw Error(`Index ${e} is not yet supported`);
+}
+function f(...e) {
+	let t;
+	switch (e.length) {
+		case 0:
+			t = "\n        fn main()\n      ";
+			break;
+		case 1:
+			t = `
+        fn main(${e[0]} : i32)
+      `;
+			break;
+		default: throw Error("Unreachable");
+	}
+	return t;
+}
+function p(e, t) {
+	let n;
+	return n = `
+     ${m(t)}
+      fn _start(@builtin(local_invocation_id) LocalId : vec3<u32>,
+                @builtin(global_invocation_id) GlobalId : vec3<u32>,
+                @builtin(local_invocation_index) LocalIndex: u32,
+                @builtin(workgroup_id) WorkgroupId : vec3<u32>,
+                ${t.subgroupBuiltins ? "@builtin(subgroup_invocation_id) SubgroupInvocationId : u32," : ""}
+                ${t.subgroupBuiltins ? "@builtin(subgroup_size) SubgroupSize : u32," : ""}
+                @builtin(num_workgroups) NumWorkgroups : vec3<u32>) {
+        localId = LocalId;
+        localIndex = LocalIndex;
+        globalId = GlobalId;
+        numWorkgroups = NumWorkgroups;
+        workgroupId = WorkgroupId;
+        ${t.subgroupBuiltins ? "subgroupInvocationId = SubgroupInvocationId" : ""};
+        ${t.subgroupBuiltins ? "subgroupSize = SubgroupSize" : ""};
+        ${e ? "main(getGlobalIndex());" : "main();"};
+      }
+    `, n;
+}
+function m(e) {
+	return `
+  @compute @workgroup_size(${e.workgroupSize[0]}, ${e.workgroupSize[1]}, ${e.workgroupSize[2]})
+`;
+}
+function h(e, t, n) {
+	let r = [], i = n.workgroupSize[0] * n.workgroupSize[1] * n.workgroupSize[2];
+	if (n.outputComponent = n.outputComponent ? n.outputComponent : 1, r.push(`
+
+      var<private> localId: vec3<u32>;
+      var<private> localIndex: u32;
+      var<private> globalId: vec3<u32>;
+      var<private> numWorkgroups: vec3<u32>;
+      var<private> workgroupId: vec3<u32>;
+      ${n.subgroupBuiltins ? "var<private> subgroupInvocationId: u32;" : ""}
+      ${n.subgroupBuiltins ? "var<private> subgroupSize: u32;" : ""}
+
+      // Only used when the y/z dimension of workgroup size is 1.
+      fn getGlobalIndex() -> i32 {
+        ${T(n) ? "  return i32(globalId.x);" : `  return i32((workgroupId.z * numWorkgroups.x * numWorkgroups.y +
+                workgroupId.y * numWorkgroups.x + workgroupId.x) * ${i}u +
+                localIndex);
+        `}
+      }
+    `), n.pixelsOpType != null) {
+		let i = n.pixelsOpType === s.FROM_PIXELS ? `@group(0) @binding(0) var<storage, read_write> result: array<${E(t.dtype, n.outputComponent)}>;` : `@group(0) @binding(1) var<storage, read> inBuf : array<${E(e[0].dtype, n.outputComponent)}>;`, a = t.shape.length === 3 ? "vec2<i32>" : "i32";
+		r.push(`
+        struct Uniform {
+          outShapeStrides : ${a},
+          size            : i32,
+          numChannels     : i32,
+          alpha           : f32,
+        };
+
+        ${i}
+        @group(0) @binding(2) var<uniform> uniforms: Uniform;
+      `);
+		let o = k(n);
+		return [
+			_,
+			r.join("\n"),
+			y(t.shape),
+			n.getUserCode(),
+			p(o, n)
+		].join("\n");
+	}
+	let a, o, c = "struct Uniforms { NAN : f32, INFINITY : f32, ";
+	n.variableNames.forEach((t, n) => {
+		let r = u(e[n].shape.length);
+		c += `${t.charAt(0).toLowerCase() + t.slice(1)}Shape : ${r}, `, a = e[n].shape.length - 1, o = u(a), c += `${t.charAt(0).toLowerCase() + t.slice(1)}ShapeStrides: ${o}, `;
+	});
+	let l = u(t.shape.length);
+	c += `outShape : ${l}, `, a = t.shape.length - 1, o = u(a), c += `
+         outShapeStrides: ${o}, `, n.size && (c += "size : i32, "), n.uniforms && (c += n.uniforms), c += "};", c = O(c), r.push(c), n.atomic ? r.push("\n      @group(0) @binding(0) var<storage, read_write> result: array<atomic<i32>>;\n    ") : r.push(`
+      @group(0) @binding(0) var<storage, read_write> result: array<${E(t.dtype, n.outputComponent)}>;
+    `), n.variableNames.forEach((t, i) => {
+		r.push(`
+      @group(0) @binding(${1 + i}) var<storage, read> ${t}: array<${n.variableComponents ? E(e[i].dtype, n.variableComponents[i]) : E(e[i].dtype, n.outputComponent)}>;
+        `);
+	}), c !== "" && r.push(`
+      @group(0) @binding(${1 + n.variableNames.length}) var<uniform> uniforms: Uniforms;
+      `);
+	let d = C(t.shape, n.dispatchLayout), f = [
+		n.subgroups ? "enable subgroups;" : "",
+		_,
+		r.join("\n") + v,
+		y(t.shape),
+		d,
+		w(t.shape.length)
+	];
+	n.atomic || f.push(D(t.shape, t.dtype, n.outputComponent)), n.variableNames.forEach((t, n) => {
+		f.push(`${y(e[n].shape, t)}`);
+	});
+	let m = e.map((e, r) => S(e, t.shape, n.variableComponents ? n.variableComponents[r] : n.outputComponent, n.dispatchLayout.x.length === t.shape.length)).join("\n");
+	f.push(m), f.push(n.getUserCode());
+	let h = k(n);
+	return f.push(p(h, n)), f.join("\n");
+}
+function g(t, r, i) {
+	let a = t.shaderKey;
+	if (t.pixelsOpType != null) return a;
+	let o = [], s = [];
+	r.forEach((e) => {
+		o.push(e.shape), s.push(e.dtype);
+	}), o.push(i.shape), s.push(i.dtype);
+	let c = r.map((t) => e(t.shape, i.shape)), l = r.map((e) => n(e.shape, i.shape)).join("_"), u = c.map((e) => e.join("_")).join(";"), d = T(t) ? "flatDispatch" : "";
+	return a += "_" + (t.workgroupSize ? t.workgroupSize.join(",") : "") + o.map((e) => e.length).join(",") + s.join(",") + t.variableNames.join(",") + u + l + d, a;
+}
+var _ = "\n  struct vec5 {x: i32, y: i32, z: i32, w: i32, u: i32};\n  struct vec6 {x: i32, y: i32, z: i32, w: i32, u: i32, v: i32};\n\n  // Checks whether coordinates lie within the bounds of the shape.\n  fn coordsInBounds2D(coord : vec2<i32>, shape : vec2<i32>) -> bool {\n    return all(coord >= vec2<i32>(0)) && all(coord < shape);\n  }\n  fn coordsInBounds3D(coord : vec3<i32>, shape : vec3<i32>) -> bool {\n    return all(coord >= vec3<i32>(0)) && all(coord < shape);\n  }\n  fn coordsInBounds4D(coord : vec4<i32>, shape : vec4<i32>) -> bool {\n    return all(coord >= vec4<i32>(0)) && all(coord < shape);\n  }\n\n  fn getIndexFromCoords1D(coord : i32, shape : i32) -> i32 {\n    return coord;\n  }\n  fn getIndexFromCoords2D(coords : vec2<i32>, shape : vec2<i32>) -> i32 {\n    return dot(coords, vec2<i32>(shape.y, 1));\n  }\n  fn getIndexFromCoords3D(coords : vec3<i32>, shape : vec3<i32>) -> i32 {\n    return dot(coords, vec3<i32>(shape.y * shape.z, shape.z, 1));\n  }\n  fn getIndexFromCoords4D(coords : vec4<i32>, shape : vec4<i32>) -> i32 {\n    return dot(coords, vec4<i32>(\n        shape.y * shape.z * shape.w, shape.z * shape.w, shape.w, 1));\n  }\n  fn getIndexFromCoords5D(coords : vec5, shape : vec5) -> i32 {\n    let shapeStrides: vec5 = vec5(shape.y * shape.z * shape.w * shape.u, shape.z * shape.w * shape.u, shape.w * shape.u, shape.u, 1);\n    return coords.x*shapeStrides.x + coords.y*shapeStrides.y + coords.z*shapeStrides.z + coords.w*shapeStrides.w + coords.u*shapeStrides.u;\n  }\n  fn getIndexFromCoords6D(coords : vec6, shape : vec6) -> i32 {\n    let shapeStrides: vec6 = vec6(shape.y * shape.z * shape.w * shape.u * shape.v, shape.z * shape.w * shape.u * shape.v, shape.w * shape.u * shape.v, shape.u * shape.v, shape.v, 1);\n    return coords.x*shapeStrides.x + coords.y*shapeStrides.y + coords.z*shapeStrides.z + coords.w*shapeStrides.w + coords.u*shapeStrides.u + coords.v*shapeStrides.v;\n  }\n\n  // NaN defination in IEEE 754-1985 is :\n  //   - sign = either 0 or 1.\n  //   - biased exponent = all 1 bits.\n  //   - fraction = anything except all 0 bits (since all 0 bits represents infinity).\n  // https://en.wikipedia.org/wiki/IEEE_754-1985#Representation_of_non-numbers\n  fn isnan(val: f32) -> bool {\n    let floatToUint: u32 = bitcast<u32>(val);\n    return (floatToUint & 0x7fffffffu) > 0x7f800000u;\n  }\n  fn isnanVec4(val : vec4<f32>) -> vec4<bool> {\n    let floatToUint: vec4<u32> = bitcast<vec4<u32>>(val);\n    return (floatToUint & vec4<u32>(0x7fffffffu)) > vec4<u32>(0x7f800000u);\n  }\n", v = "\n  fn isinf(val: f32) -> bool {\n    return abs(val) == uniforms.INFINITY;\n  }\n";
+function y(e, t = "") {
+	let n = e.length, r = t === "" ? "getCoordsFromIndex" : `get${t.charAt(0).toUpperCase() + t.slice(1)}CoordsFromIndex`, a = t === "" ? "outShapeStrides" : `${t.charAt(0).toLowerCase() + t.slice(1)}ShapeStrides`;
+	if (n <= 1) return `fn ${r}(index : i32) -> i32 { return index; }`;
+	let o = i(e), s = u(n), c = [];
+	for (let e = 0; e < n; e++) c.push(`d${e}`);
+	if (o.length === 1) return `    fn ${r}(index : i32) -> vec2<i32> {
+      let d0 = index / uniforms.${a}; let d1 = index - d0 * uniforms.${a};
+      return vec2<i32>(d0, d1);
+    }`;
+	let l;
+	return l = "var index2 = index;" + o.map((e, t) => `${`let ${c[t]} = index2 / uniforms.${a}.${d(t)}`}; ${t === o.length - 1 ? `let ${c[t + 1]} = index2 - ${c[t]} * uniforms.${a}.${d(t)}` : `index2 = index2 - ${c[t]} * uniforms.${a}.${d(t)}`};`).join(""), `
+    fn ${r}(index : i32) -> ${s} {
+      ${l}
+      return ${s}(${c.join(",")});
+    }
+  `;
+}
+function b(e, t) {
+	let n = e.name, r = e.shape.length, i = u(r), a = "get" + n.charAt(0).toUpperCase() + n.slice(1), o = [
+		"d0",
+		"d1",
+		"d2",
+		"d3",
+		"d4",
+		"d5"
+	].slice(0, r), s = o.map((e) => `${e} : i32`).join(", ");
+	if (r < 1) return `
+      fn ${a}() -> ${l(t)} {
+        return ${l(t)}(${n}[0]);
+      }
+    `;
+	let c = `uniforms.${n.charAt(0).toLowerCase() + n.slice(1)}Shape`, d = `${r}D`;
+	return r === 0 && (d = "1D"), `
+    fn ${a}(${s}) -> ${l(t)} {
+      return ${l(t)}(${n}[getIndexFromCoords${d}(${i}(${o.join(",")}),
+        ${c})${t === 1 ? "" : ` / ${t}`}]);
+    }
+   `;
+}
+function x(t, r, i, a) {
+	let o = t.name, s = o.charAt(0).toUpperCase() + o.slice(1), c = "get" + s + "ByOutput", f = t.shape.length, p = r.length, m = u(p);
+	if (n(t.shape, r) && a) return `
+    fn ${c}Index(globalIndex : i32) -> ${l(i)} {
+      return ${l(i)}(${o}[globalIndex]);
+    }
+
+    fn ${c}Coords(coords : ${m}) -> ${l(i)} {
+      return ${l(i)}(${o}[${p > 1 ? "getOutputIndexFromCoords(coords)" : "coords"}${i === 1 ? "" : ` / ${i}`}]);
+    }
+    `;
+	let h = e(t.shape, r), g = p - f, _ = "";
+	if (f === 0) return `
+    fn ${c}Index(globalIndex : i32) -> ${l(i)}{
+      return get${s}();
+    }
+
+    fn ${c}Coords(coords : ${m}) -> ${l(i)}{
+      return get${s}();
+    }
+  `;
+	_ = p < 2 && h.length >= 1 ? "coords = 0;" : h.map((e) => `coords.${d(e + g)} = 0;`).join("\n");
+	let v = "";
+	v = p < 2 && f > 0 ? "coords" : p > 1 ? `${u(f)}(${t.shape.map((e, t) => `coords.${d(t + g)}`).join(", ")})` : "coords";
+	let y = `uniforms.${o.charAt(0).toLowerCase() + o.slice(1)}Shape`, b = `${f}D`;
+	return `
+  fn ${c}Index(globalIndex : i32) -> ${l(i)} {
+    var coords = getCoordsFromIndex(globalIndex);
+    ${_}
+    return ${l(i)}(${o}[getIndexFromCoords${b}(${v}, ${y})${i === 1 ? "" : ` / ${i}`}]);
+  }
+
+  fn ${c}Coords(coordsIn : ${m}) -> ${l(i)} {
+    var coords = coordsIn;
+    ${_}
+    return ${l(i)}(${o}[getIndexFromCoords${b}(${v}, ${y})${i === 1 ? "" : ` / ${i}`}]);
+  }
+`;
+}
+function S(e, t, n, r) {
+	let i = b(e, n);
+	return e.shape.length <= t.length && (i += x(e, t, n, r)), i;
+}
+function C(e, t) {
+	let { x: n, y: r = [], z: i = [] } = t, o = e.length, s = n.length + r.length + i.length;
+	if (s !== o) return "";
+	if (n.length === o) return `fn getOutputCoords() -> ${u(o)}{
+    let globalIndex = getGlobalIndex();
+    return getCoordsFromIndex(globalIndex);
+  }
+  `;
+	let c = "", l = [
+		n,
+		r,
+		i
+	];
+	for (let e = 0; e < l.length; e++) {
+		let t = l[e];
+		if (t.length !== 0) if (t.length === 1) c += `let d${t[0]} = i32(globalId[${e}]);`;
+		else {
+			let n = a(t, "uniforms.outShape");
+			c += `var index${e} = i32(globalId[${e}]);`;
+			for (let r = 0; r < n.length; r++) c += `let d${t[r]} = index${e} / ${n[r]};`, r === n.length - 1 ? c += `let d${t[r + 1]} = index${e} - d${t[r]} * ${n[r]};` : c += `index${e} = index${e} - d${t[r]} * ${n[r]};`;
+		}
+	}
+	let d = [];
+	for (let e = 0; e < s; e++) d.push(`d${e}`);
+	let f = u(s), p = `fn getOutputCoords() -> ${f} {
+  ${c}
+`;
+	return d.length === 0 ? p += `return ${f}(0); }` : p += `return ${f}(${d.join(",")}); }`, p;
+}
+function w(e) {
+	let t = "";
+	switch (e) {
+		case 0:
+		case 1:
+			t += "\n        fn getOutputIndexFromCoords(coords : i32) -> i32 {\n          return coords;\n        }\n        ";
+			break;
+		case 2:
+			t += "\n        fn getOutputIndexFromCoords(coords : vec2<i32>) -> i32 {\n          return dot(coords, vec2<i32>(uniforms.outShapeStrides, 1));\n        }\n        ";
+			break;
+		case 3:
+			t += "\n        fn getOutputIndexFromCoords(coords : vec3<i32>) -> i32 {\n          return dot(coords, vec3<i32>(uniforms.outShapeStrides.x, uniforms.outShapeStrides.y, 1));\n        }\n        ";
+			break;
+		case 4:
+			t += "\n        fn getOutputIndexFromCoords(coords : vec4<i32>) -> i32 {\n          return dot(coords, vec4<i32>(\n            uniforms.outShapeStrides.x, uniforms.outShapeStrides.y, uniforms.outShapeStrides.z, 1));\n        }\n        ";
+			break;
+		case 5:
+			t += "\n        fn getOutputIndexFromCoords(coords : vec5) -> i32 {\n          return coords.x * uniforms.outShapeStrides.x +\n              coords.y * uniforms.outShapeStrides.y +\n              coords.z * uniforms.outShapeStrides.z +\n              coords.w * uniforms.outShapeStrides.w +\n              coords.u;\n        }\n        ";
+			break;
+		case 6:
+			t += "\n        fn getOutputIndexFromCoords(coords : vec6) -> i32 {\n          return coords.x * uniforms.outShapeStrides.x +\n              coords.y * uniforms.outShapeStrides.y +\n              coords.z * uniforms.outShapeStrides.z +\n              coords.w * uniforms.outShapeStrides.w +\n              coords.u * uniforms.outShapeStrides.u +\n              coords.v;\n        }\n        ";
+			break;
+		default:
+			r(!1, () => `Unsupported ${e}D shape`);
+			break;
+	}
+	return t;
+}
+function T(e) {
+	return e.dispatch[1] === 1 && e.dispatch[2] === 1;
+}
+function E(e, t = 1) {
+	if (e === "float32") return l(t, "f32");
+	if (e === "int32" || e === "bool" || e === "packedF16") return l(t, "i32");
+	throw Error(`type ${e} is not supported.`);
+}
+function D(e, t, n) {
+	let r = e.length, i = E(t, n), a = `fn setOutputAtIndex(flatIndex : i32, value : ${l(n)}) {
+      result[flatIndex] = ${i}(value);
+    }
+
+    fn setOutputAtIndexI32(flatIndex : i32, value : ${l(n, "i32")}) {
+      result[flatIndex] = ${i}(value);
+    }
+    `;
+	if (r >= 2) {
+		let e = [
+			"d0",
+			"d1",
+			"d2",
+			"d3",
+			"d4",
+			"d5"
+		].slice(0, r), t = u(r);
+		a += `
+      fn setOutputAtCoords(${e.map((e) => `${e} : i32`).join(", ")}, value : ${l(n)}) {
+        let flatIndex = getOutputIndexFromCoords(${t}(${e.join(", ")}));
+        setOutputAtIndex(flatIndex${n === 1 ? "" : ` / ${n}`}, value);
+      }
+      fn setOutputAtCoordsI32(${e.map((e) => `${e} : i32`).join(", ")}, value : ${l(n, "i32")}) {
+        let flatIndex = getOutputIndexFromCoords(${t}(${e.join(", ")}));
+        setOutputAtIndexI32(flatIndex${n === 1 ? "" : ` / ${n}`}, value);
+      }
+    `;
+	}
+	return a;
+}
+function O(e) {
+	return e = e.replace(/(\w+)\s*:\s*vec(5|6)/g, (e) => "@align(16) " + e), e = e.replace(/vec(5|6)\s*,\s*(\w+)/g, (e, t, n) => `vec${t}, @align(16) ${n}`), e;
+}
+function k(e) {
+	return !(e.dispatchLayout.hasOwnProperty("y") && e.dispatchLayout.y.length !== 0 || e.dispatchLayout.hasOwnProperty("z") && e.dispatchLayout.z.length !== 0);
+}
+//#endregion
+export { y as a, m as c, o as d, a as f, u as i, g as l, c as n, d as o, E as r, f as s, s as t, l as u };

package/dist/webgpu_util-B_F3SShA.js

@@ -0,0 +1,106 @@
+import { Ps as e } from "./dist-BewPQWjc.js";
+//#region node_modules/@tensorflow/tfjs-backend-webgpu/dist/webgpu_util.js
+var t = (e) => {
+	let t = 1;
+	for (let n = 0; n < e.length; n++) t *= e[n];
+	return t;
+};
+function n(e, n, r = [
+	1,
+	1,
+	1
+], i = [
+	1,
+	1,
+	1
+]) {
+	let [a, o, s] = [
+		Math.ceil(t(e.x.map((e) => n[e])) / (r[0] * i[0])),
+		e.y ? Math.ceil(t(e.y.map((e) => n[e])) / (r[1] * i[1])) : 1,
+		e.z ? Math.ceil(t(e.z.map((e) => n[e])) / (r[2] * i[2])) : 1
+	];
+	return [
+		a,
+		o,
+		s
+	];
+}
+function r(e, t, n, r = !1) {
+	let i = [
+		8,
+		8,
+		1
+	], a = [
+		4,
+		4,
+		1
+	];
+	return r || (e <= 8 && (a[1] = 1), t <= 16 && n <= 16 && (i[0] = 4)), {
+		workgroupSize: i,
+		elementsPerThread: a
+	};
+}
+function i(e, n, r = !1) {
+	if (r) return [
+		8,
+		8,
+		1
+	];
+	let i = t(e.x.map((e) => n[e])), a = t(e.y.map((e) => n[e]));
+	return i <= 4 ? [
+		4,
+		16,
+		1
+	] : a <= 4 ? [
+		16,
+		4,
+		1
+	] : [
+		16,
+		16,
+		1
+	];
+}
+function a(e, n, r = !1) {
+	if (r) return [
+		4,
+		4,
+		1
+	];
+	let i = t(e.x.map((e) => n[e])), a = t(e.y.map((e) => n[e]));
+	return i <= 4 ? [
+		1,
+		2,
+		1
+	] : a <= 4 ? [
+		2,
+		1,
+		1
+	] : [
+		2,
+		2,
+		1
+	];
+}
+function o(e) {
+	return { x: e.map((e, t) => t) };
+}
+function s(e) {
+	if (e === "float32" || e === "int32" || e === "bool" || e === "string" || e === "packedF16") return 4;
+	if (e === "complex64") return 8;
+	throw Error(`Unknown dtype ${e}`);
+}
+function c() {
+	return !!(typeof globalThis < "u" && globalThis.navigator && globalThis.navigator.gpu);
+}
+function l(t, n) {
+	Array.isArray(t) || (t = [t]), t.forEach((t) => {
+		t != null && e(t.dtype !== "complex64", () => `${n} does not support complex64 tensors in the WebGPU backend.`);
+	});
+}
+var u;
+(function(e) {
+	e[e.MatMulReduceProgram = 0] = "MatMulReduceProgram", e[e.MatMulSplitKProgram = 1] = "MatMulSplitKProgram", e[e.MatMulSmallOutputSizeProgram = 2] = "MatMulSmallOutputSizeProgram", e[e.MatMulPackedProgram = 3] = "MatMulPackedProgram", e[e.MatMulMax = 4] = "MatMulMax";
+})(u ||= {});
+//#endregion
+export { a, o as c, n as i, c as l, u as n, r as o, l as r, i as s, s as t };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@genai-fi/nanogpt",
-    "version": "0.19.1",
+    "version": "0.20.1",
     "type": "module",
     "main": "dist/main.js",
     "types": "dist/main.d.ts",
@@ -33,24 +33,23 @@
         "@types/papaparse": "^5.3.16",
         "@types/picomatch": "^4.0.2",
         "@types/yargs": "^17.0.33",
-        "@vitest/coverage-v8": "^4.1.8",
+        "@vitest/coverage-v8": "^4.1.9",
         "chalk": "^5.4.1",
         "dayjs": "^1.11.13",
         "eslint": "^9.32.0",
         "glob": "^11.0.3",
         "jsdom": "^27.4.0",
         "tsx": "^4.20.3",
-        "typescript": "^5.8.3",
-        "typescript-eslint": "^8.38.0",
-        "vite": "^7.3.0",
-        "vite-plugin-dts": "^4.5.4",
-        "vite-plugin-node-polyfills": "^0.26.0",
-        "vitest": "^4.1.8",
-        "webgpu": "^0.3.8",
+        "typescript": "^6.0.3",
+        "typescript-eslint": "^8.61.1",
+        "vite": "^8.0.16",
+        "vite-plugin-dts": "^5.0.2",
+        "vite-plugin-node-polyfills": "^0.28.0",
+        "vitest": "^4.1.9",
+        "webgpu": "^0.4.0",
         "yargs": "^18.0.0"
     },
     "dependencies": {
-        "@dsnp/parquetjs": "^1.8.7",
         "@tensorflow/tfjs": "^4.22.0",
         "@tensorflow/tfjs-backend-webgpu": "^4.22.0",
         "eventemitter3": "^5.0.1",