@genai-fi/nanogpt 0.10.2 → 0.10.3

package/dist/{webgpu_program-DzaQiqel.js → webgpu_program-DuOXPQol.js}

@@ -1,50 +1,49 @@
-import { h as k } from "./index-D6Q1lPZO.js";
-import { b as z, e as E, i as j, a as A } from "./tensor-CzmOBsdf.js";
-function L(e, s) {
-  if (Math.max(...e) > 5)
+import { o as z, n as F, j, ad as E, l as A } from "./index-DOvlwCh-.js";
+function L(t, s) {
+  if (Math.max(...t) > 5)
     throw new Error("Cannot symbolically compute strides for rank > 6 tensor.");
-  const t = e.length, o = "xyzwuv", i = e.map((n) => `${s}.${o[n]}`), u = new Array(t - 1);
-  u[t - 2] = i[t - 1];
-  for (let n = t - 3; n >= 0; --n)
+  const e = t.length, o = "xyzwuv", i = t.map((n) => `${s}.${o[n]}`), u = new Array(e - 1);
+  u[e - 2] = i[e - 1];
+  for (let n = e - 3; n >= 0; --n)
     u[n] = `(${u[n + 1]} * ${i[n + 1]})`;
   return u;
 }
-const H = (e, s, t) => t === "int32" ? `atomicAdd(${e}, bitcast<i32>(${s}));` : `
+const X = (t, s, e) => e === "int32" ? `atomicAdd(${t}, bitcast<i32>(${s}));` : `
           {
             var oldValue = 0;
             loop {
               let newValueF32 = bitcast<f32>(oldValue) + (${s});
               let newValue = bitcast<i32>(newValueF32);
-              let res = atomicCompareExchangeWeak(${e}, oldValue, newValue);
+              let res = atomicCompareExchangeWeak(${t}, oldValue, newValue);
               if res.exchanged {
                 break;
               }
               oldValue = res.old_value;
             }
           }`;
-var b;
-(function(e) {
-  e[e.FROM_PIXELS = 0] = "FROM_PIXELS", e[e.DRAW = 1] = "DRAW";
-})(b || (b = {}));
-const Y = (e, s, t, o, i) => {
-  const u = { dtype: o.dtype, shape: o.shape }, n = D(t, u, s), r = e.createShaderModule({ code: n, label: s.constructor.name });
-  let d = E().get("WEBGPU_PRINT_SHADER");
+var w;
+(function(t) {
+  t[t.FROM_PIXELS = 0] = "FROM_PIXELS", t[t.DRAW = 1] = "DRAW";
+})(w || (w = {}));
+const H = (t, s, e, o, i) => {
+  const u = { dtype: o.dtype, shape: o.shape }, n = D(e, u, s), r = t.createShaderModule({ code: n, label: s.constructor.name });
+  let d = j().get("WEBGPU_PRINT_SHADER");
   if (d !== "") {
     d = d.toLowerCase();
     const p = d.split(",");
     (d === "all" || p.some((a) => s.shaderKey.toLowerCase().includes(a))) && (console.group(s.shaderKey), console.debug(n), console.groupEnd());
   }
-  return i ? e.createComputePipelineAsync({
+  return i ? t.createComputePipelineAsync({
     compute: { module: r, entryPoint: "_start" },
     label: s.constructor.name,
     layout: "auto"
-  }) : e.createComputePipeline({
+  }) : t.createComputePipeline({
     compute: { module: r, entryPoint: "_start" },
     label: s.constructor.name,
     layout: "auto"
   });
-}, f = (e, s = "f32") => {
-  switch (e) {
+}, h = (t, s = "f32") => {
+  switch (t) {
     case 1:
       return `${s}`;
     case 2:
@@ -54,42 +53,42 @@ const Y = (e, s, t, o, i) => {
     case 4:
       return `vec4<${s}>`;
     default:
-      throw new Error(`${e}-component ${s} is not supported.`);
+      throw new Error(`${t}-component ${s} is not supported.`);
   }
 };
-function v(e) {
-  if (e <= 1)
+function g(t) {
+  if (t <= 1)
     return "i32";
-  if (e === 2)
+  if (t === 2)
     return "vec2<i32>";
-  if (e === 3)
+  if (t === 3)
     return "vec3<i32>";
-  if (e === 4)
+  if (t === 4)
     return "vec4<i32>";
-  if (e === 5)
+  if (t === 5)
     return "vec5";
-  if (e === 6)
+  if (t === 6)
     return "vec6";
-  throw Error(`GPU for rank ${e} is not yet supported`);
+  throw Error(`GPU for rank ${t} is not yet supported`);
 }
-function I(e) {
-  if (e === 0)
+function I(t) {
+  if (t === 0)
     return "x";
-  if (e === 1)
+  if (t === 1)
     return "y";
-  if (e === 2)
+  if (t === 2)
     return "z";
-  if (e === 3)
+  if (t === 3)
     return "w";
-  if (e === 4)
+  if (t === 4)
     return "u";
-  if (e === 5)
+  if (t === 5)
     return "v";
-  throw Error(`Index ${e} is not yet supported`);
+  throw Error(`Index ${t} is not yet supported`);
 }
-function q(...e) {
+function Y(...t) {
   let s;
-  switch (e.length) {
+  switch (t.length) {
     case 0:
       s = `
         fn main()
@@ -97,7 +96,7 @@ function q(...e) {
       break;
     case 1:
       s = `
-        fn main(${e[0]} : i32)
+        fn main(${t[0]} : i32)
       `;
       break;
     default:
@@ -105,118 +104,125 @@ function q(...e) {
   }
   return s;
 }
-function w(e, s) {
-  let t;
-  return t = `
+function C(t, s) {
+  let e;
+  return e = `
      ${N(s)}
       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>,
+                ${s.subgroupBuiltins ? "@builtin(subgroup_invocation_id) SubgroupInvocationId : u32," : ""}
+                ${s.subgroupBuiltins ? "@builtin(subgroup_size) SubgroupSize : u32," : ""}
                 @builtin(num_workgroups) NumWorkgroups : vec3<u32>) {
         localId = LocalId;
         localIndex = LocalIndex;
         globalId = GlobalId;
         numWorkgroups = NumWorkgroups;
         workgroupId = WorkgroupId;
-        ${e ? "main(getGlobalIndex());" : "main();"};
+        ${s.subgroupBuiltins ? "subgroupInvocationId = SubgroupInvocationId" : ""};
+        ${s.subgroupBuiltins ? "subgroupSize = SubgroupSize" : ""};
+        ${t ? "main(getGlobalIndex());" : "main();"};
       }
-    `, t;
+    `, e;
 }
-function N(e) {
+function N(t) {
   return `
-  @compute @workgroup_size(${e.workgroupSize[0]}, ${e.workgroupSize[1]}, ${e.workgroupSize[2]})
+  @compute @workgroup_size(${t.workgroupSize[0]}, ${t.workgroupSize[1]}, ${t.workgroupSize[2]})
 `;
 }
-function D(e, s, t) {
-  const o = [], i = t.workgroupSize[0] * t.workgroupSize[1] * t.workgroupSize[2];
-  if (t.outputComponent = t.outputComponent ? t.outputComponent : 1, o.push(`
+function D(t, s, e) {
+  const o = [], i = e.workgroupSize[0] * e.workgroupSize[1] * e.workgroupSize[2];
+  if (e.outputComponent = e.outputComponent ? e.outputComponent : 1, o.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>;
+      ${e.subgroupBuiltins ? "var<private> subgroupInvocationId: u32;" : ""}
+      ${e.subgroupBuiltins ? "var<private> subgroupSize: u32;" : ""}
 
       // Only used when the y/z dimension of workgroup size is 1.
       fn getGlobalIndex() -> i32 {
-        ${F(t) ? "  return i32(globalId.x);" : `  return i32((workgroupId.z * numWorkgroups.x * numWorkgroups.y +
+        ${_(e) ? "  return i32(globalId.x);" : `  return i32((workgroupId.z * numWorkgroups.x * numWorkgroups.y +
                 workgroupId.y * numWorkgroups.x + workgroupId.x) * ${i}u +
                 localIndex);
         `}
       }
-    `), t.pixelsOpType != null) {
-    const h = t.pixelsOpType === b.FROM_PIXELS ? `@group(0) @binding(0) var<storage, read_write> result: array<${x(s.dtype, t.outputComponent)}>;` : `@group(0) @binding(1) var<storage, read> inBuf : array<${x(e[0].dtype, t.outputComponent)}>;`, c = s.shape.length === 3 ? "vec2<i32>" : "i32";
+    `), e.pixelsOpType != null) {
+    const c = e.pixelsOpType === w.FROM_PIXELS ? `@group(0) @binding(0) var<storage, read_write> result: array<${b(s.dtype, e.outputComponent)}>;` : `@group(0) @binding(1) var<storage, read> inBuf : array<${b(t[0].dtype, e.outputComponent)}>;`, $ = s.shape.length === 3 ? "vec2<i32>" : "i32";
     o.push(`
         struct Uniform {
-          outShapeStrides : ${c},
+          outShapeStrides : ${$},
           size            : i32,
           numChannels     : i32,
           alpha           : f32,
         };
 
-        ${h}
+        ${c}
         @group(0) @binding(2) var<uniform> uniforms: Uniform;
       `);
-    const S = m(t);
+    const x = k(e);
     return [
-      C,
+      m,
       o.join(`
 `),
       y(s.shape),
-      t.getUserCode(),
-      w(S, t)
+      e.getUserCode(),
+      C(x, e)
     ].join(`
 `);
   }
   let u, n, r = "struct Uniforms { NAN : f32, INFINITY : f32, ";
-  t.variableNames.forEach((h, c) => {
-    const S = v(e[c].shape.length);
-    r += `${h.charAt(0).toLowerCase() + h.slice(1)}Shape : ${S}, `, u = e[c].shape.length - 1, n = v(u), r += `${h.charAt(0).toLowerCase() + h.slice(1)}ShapeStrides: ${n}, `;
+  e.variableNames.forEach((c, $) => {
+    const x = g(t[$].shape.length);
+    r += `${c.charAt(0).toLowerCase() + c.slice(1)}Shape : ${x}, `, u = t[$].shape.length - 1, n = g(u), r += `${c.charAt(0).toLowerCase() + c.slice(1)}ShapeStrides: ${n}, `;
   });
-  const d = v(s.shape.length);
-  r += `outShape : ${d}, `, u = s.shape.length - 1, n = v(u), r += `
-         outShapeStrides: ${n}, `, t.size && (r += "size : i32, "), t.uniforms && (r += t.uniforms), r += "};", r = B(r), o.push(r), t.atomic ? o.push(`
+  const d = g(s.shape.length);
+  r += `outShape : ${d}, `, u = s.shape.length - 1, n = g(u), r += `
+         outShapeStrides: ${n}, `, e.size && (r += "size : i32, "), e.uniforms && (r += e.uniforms), r += "};", r = V(r), o.push(r), e.atomic ? o.push(`
       @group(0) @binding(0) var<storage, read_write> result: array<atomic<i32>>;
     `) : o.push(`
-      @group(0) @binding(0) var<storage, read_write> result: array<${x(s.dtype, t.outputComponent)}>;
-    `), t.variableNames.forEach((h, c) => {
+      @group(0) @binding(0) var<storage, read_write> result: array<${b(s.dtype, e.outputComponent)}>;
+    `), e.variableNames.forEach((c, $) => {
     o.push(`
-      @group(0) @binding(${1 + c}) var<storage, read> ${h}: array<${t.variableComponents ? x(e[c].dtype, t.variableComponents[c]) : x(e[c].dtype, t.outputComponent)}>;
+      @group(0) @binding(${1 + $}) var<storage, read> ${c}: array<${e.variableComponents ? b(t[$].dtype, e.variableComponents[$]) : b(t[$].dtype, e.outputComponent)}>;
         `);
   }), r !== "" && o.push(`
-      @group(0) @binding(${1 + t.variableNames.length}) var<uniform> uniforms: Uniforms;
+      @group(0) @binding(${1 + e.variableNames.length}) var<uniform> uniforms: Uniforms;
       `);
-  const p = R(s.shape, t.dispatchLayout), a = [
-    C,
+  const p = P(s.shape, e.dispatchLayout), v = [
+    e.subgroups ? "enable subgroups;" : "",
+    m,
     o.join(`
 `) + T,
     y(s.shape),
     p,
-    G(s.shape.length)
+    R(s.shape.length)
   ];
-  t.atomic || a.push(V(s.shape, s.dtype, t.outputComponent)), t.variableNames.forEach((h, c) => {
-    a.push(`${y(e[c].shape, h)}`);
+  e.atomic || v.push(G(s.shape, s.dtype, e.outputComponent)), e.variableNames.forEach((c, $) => {
+    v.push(`${y(t[$].shape, c)}`);
   });
-  const g = e.map((h, c) => P(h, s.shape, t.variableComponents ? t.variableComponents[c] : t.outputComponent, t.dispatchLayout.x.length === s.shape.length)).join(`
+  const l = t.map((c, $) => B(c, s.shape, e.variableComponents ? e.variableComponents[$] : e.outputComponent, e.dispatchLayout.x.length === s.shape.length)).join(`
 `);
-  a.push(g), a.push(t.getUserCode());
-  const l = m(t);
-  return a.push(w(l, t)), a.join(`
+  v.push(l), v.push(e.getUserCode());
+  const f = k(e);
+  return v.push(C(f, e)), v.join(`
 `);
 }
-function Z(e, s, t) {
-  let o = e.shaderKey;
-  if (e.pixelsOpType != null)
+function q(t, s, e) {
+  let o = t.shaderKey;
+  if (t.pixelsOpType != null)
     return o;
   const i = [], u = [];
   s.forEach((a) => {
     i.push(a.shape), u.push(a.dtype);
-  }), i.push(t.shape), u.push(t.dtype);
-  const n = s.map((a) => k(a.shape, t.shape)), r = s.map((a) => z(a.shape, t.shape)).join("_"), d = n.map((a) => a.join("_")).join(";"), p = F(e) ? "flatDispatch" : "";
-  return o += "_" + (e.workgroupSize ? e.workgroupSize.join(",") : "") + i.map((a) => a.length).join(",") + u.join(",") + e.variableNames.join(",") + d + r + p, o;
+  }), i.push(e.shape), u.push(e.dtype);
+  const n = s.map((a) => z(a.shape, e.shape)), r = s.map((a) => F(a.shape, e.shape)).join("_"), d = n.map((a) => a.join("_")).join(";"), p = _(t) ? "flatDispatch" : "";
+  return o += "_" + (t.workgroupSize ? t.workgroupSize.join(",") : "") + i.map((a) => a.length).join(",") + u.join(",") + t.variableNames.join(",") + d + r + p, o;
 }
-const C = `
+const m = `
   struct vec5 {x: i32, y: i32, z: i32, w: i32, u: i32};
   struct vec6 {x: i32, y: i32, z: i32, w: i32, u: i32, v: i32};
 
@@ -271,12 +277,12 @@ const C = `
     return abs(val) == uniforms.INFINITY;
   }
 `;
-function y(e, s = "") {
-  const t = e.length, o = s !== "" ? `get${s.charAt(0).toUpperCase() + s.slice(1)}CoordsFromIndex` : "getCoordsFromIndex", i = s !== "" ? `${s.charAt(0).toLowerCase() + s.slice(1)}ShapeStrides` : "outShapeStrides";
-  if (t <= 1)
+function y(t, s = "") {
+  const e = t.length, o = s !== "" ? `get${s.charAt(0).toUpperCase() + s.slice(1)}CoordsFromIndex` : "getCoordsFromIndex", i = s !== "" ? `${s.charAt(0).toLowerCase() + s.slice(1)}ShapeStrides` : "outShapeStrides";
+  if (e <= 1)
     return `fn ${o}(index : i32) -> i32 { return index; }`;
-  const u = j(e), n = v(t), r = [];
-  for (let p = 0; p < t; p++)
+  const u = E(t), n = g(e), r = [];
+  for (let p = 0; p < e; p++)
     r.push(`d${p}`);
   if (u.length === 1)
     return `    fn ${o}(index : i32) -> vec2<i32> {
@@ -285,8 +291,8 @@ function y(e, s = "") {
     }`;
   let d;
   return d = "var index2 = index;" + u.map((p, a) => {
-    const g = `let ${r[a]} = index2 / uniforms.${i}.${I(a)}`, l = a === u.length - 1 ? `let ${r[a + 1]} = index2 - ${r[a]} * uniforms.${i}.${I(a)}` : `index2 = index2 - ${r[a]} * uniforms.${i}.${I(a)}`;
-    return `${g}; ${l};`;
+    const v = `let ${r[a]} = index2 / uniforms.${i}.${I(a)}`, l = a === u.length - 1 ? `let ${r[a + 1]} = index2 - ${r[a]} * uniforms.${i}.${I(a)}` : `index2 = index2 - ${r[a]} * uniforms.${i}.${I(a)}`;
+    return `${v}; ${l};`;
   }).join(""), `
     fn ${o}(index : i32) -> ${n} {
       ${d}
@@ -294,112 +300,112 @@ function y(e, s = "") {
     }
   `;
 }
-function U(e, s) {
-  const t = e.name, o = e.shape.length, i = v(o), u = "get" + t.charAt(0).toUpperCase() + t.slice(1), n = ["d0", "d1", "d2", "d3", "d4", "d5"].slice(0, o), r = n.map((a) => `${a} : i32`).join(", ");
+function U(t, s) {
+  const e = t.name, o = t.shape.length, i = g(o), u = "get" + e.charAt(0).toUpperCase() + e.slice(1), n = ["d0", "d1", "d2", "d3", "d4", "d5"].slice(0, o), r = n.map((a) => `${a} : i32`).join(", ");
   if (o < 1)
     return `
-      fn ${u}() -> ${f(s)} {
-        return ${f(s)}(${t}[0]);
+      fn ${u}() -> ${h(s)} {
+        return ${h(s)}(${e}[0]);
       }
     `;
-  const d = `uniforms.${t.charAt(0).toLowerCase() + t.slice(1)}Shape`;
+  const d = `uniforms.${e.charAt(0).toLowerCase() + e.slice(1)}Shape`;
   let p = `${o}D`;
   return o === 0 && (p = "1D"), `
-    fn ${u}(${r}) -> ${f(s)} {
-      return ${f(s)}(${t}[getIndexFromCoords${p}(${i}(${n.join(",")}),
+    fn ${u}(${r}) -> ${h(s)} {
+      return ${h(s)}(${e}[getIndexFromCoords${p}(${i}(${n.join(",")}),
         ${d})${s === 1 ? "" : ` / ${s}`}]);
     }
    `;
 }
-function W(e, s, t, o) {
-  const i = e.name, u = i.charAt(0).toUpperCase() + i.slice(1), n = "get" + u + "ByOutput", r = e.shape.length, d = s.length, p = v(d);
-  if (z(e.shape, s) && o)
+function W(t, s, e, o) {
+  const i = t.name, u = i.charAt(0).toUpperCase() + i.slice(1), n = "get" + u + "ByOutput", r = t.shape.length, d = s.length, p = g(d);
+  if (F(t.shape, s) && o)
     return `
-    fn ${n}Index(globalIndex : i32) -> ${f(t)} {
-      return ${f(t)}(${i}[globalIndex]);
+    fn ${n}Index(globalIndex : i32) -> ${h(e)} {
+      return ${h(e)}(${i}[globalIndex]);
     }
 
-    fn ${n}Coords(coords : ${p}) -> ${f(t)} {
-      return ${f(t)}(${i}[${d > 1 ? "getOutputIndexFromCoords(coords)" : "coords"}${t === 1 ? "" : ` / ${t}`}]);
+    fn ${n}Coords(coords : ${p}) -> ${h(e)} {
+      return ${h(e)}(${i}[${d > 1 ? "getOutputIndexFromCoords(coords)" : "coords"}${e === 1 ? "" : ` / ${e}`}]);
     }
     `;
-  const a = k(e.shape, s), g = d - r;
+  const a = z(t.shape, s), v = d - r;
   let l = "";
   if (r === 0)
     return `
-    fn ${n}Index(globalIndex : i32) -> ${f(t)}{
+    fn ${n}Index(globalIndex : i32) -> ${h(e)}{
       return get${u}();
     }
 
-    fn ${n}Coords(coords : ${p}) -> ${f(t)}{
+    fn ${n}Coords(coords : ${p}) -> ${h(e)}{
       return get${u}();
     }
   `;
-  d < 2 && a.length >= 1 ? l = "coords = 0;" : l = a.map((S) => `coords.${I(S + g)} = 0;`).join(`
+  d < 2 && a.length >= 1 ? l = "coords = 0;" : l = a.map(($) => `coords.${I($ + v)} = 0;`).join(`
 `);
-  let $ = "";
+  let f = "";
   if (d < 2 && r > 0)
-    $ = "coords";
+    f = "coords";
   else if (d > 1) {
-    const S = v(r), O = e.shape.map((M, _) => `coords.${I(_ + g)}`).join(", ");
-    $ = `${S}(${O})`;
+    const $ = g(r), x = t.shape.map((M, O) => `coords.${I(O + v)}`).join(", ");
+    f = `${$}(${x})`;
   } else
-    $ = "coords";
-  const h = `uniforms.${i.charAt(0).toLowerCase() + i.slice(1)}Shape`, c = `${r}D`;
+    f = "coords";
+  const S = `uniforms.${i.charAt(0).toLowerCase() + i.slice(1)}Shape`, c = `${r}D`;
   return `
-  fn ${n}Index(globalIndex : i32) -> ${f(t)} {
+  fn ${n}Index(globalIndex : i32) -> ${h(e)} {
     var coords = getCoordsFromIndex(globalIndex);
     ${l}
-    return ${f(t)}(${i}[getIndexFromCoords${c}(${$}, ${h})${t === 1 ? "" : ` / ${t}`}]);
+    return ${h(e)}(${i}[getIndexFromCoords${c}(${f}, ${S})${e === 1 ? "" : ` / ${e}`}]);
   }
 
-  fn ${n}Coords(coordsIn : ${p}) -> ${f(t)} {
+  fn ${n}Coords(coordsIn : ${p}) -> ${h(e)} {
     var coords = coordsIn;
     ${l}
-    return ${f(t)}(${i}[getIndexFromCoords${c}(${$}, ${h})${t === 1 ? "" : ` / ${t}`}]);
+    return ${h(e)}(${i}[getIndexFromCoords${c}(${f}, ${S})${e === 1 ? "" : ` / ${e}`}]);
   }
 `;
 }
-function P(e, s, t, o) {
-  let i = U(e, t);
-  return e.shape.length <= s.length && (i += W(e, s, t, o)), i;
+function B(t, s, e, o) {
+  let i = U(t, e);
+  return t.shape.length <= s.length && (i += W(t, s, e, o)), i;
 }
-function R(e, s) {
-  const { x: t, y: o = [], z: i = [] } = s, u = e.length, n = t.length + o.length + i.length;
+function P(t, s) {
+  const { x: e, y: o = [], z: i = [] } = s, u = t.length, n = e.length + o.length + i.length;
   if (n !== u)
     return "";
-  if (t.length === u)
-    return `fn getOutputCoords() -> ${v(u)}{
+  if (e.length === u)
+    return `fn getOutputCoords() -> ${g(u)}{
     let globalIndex = getGlobalIndex();
     return getCoordsFromIndex(globalIndex);
   }
   `;
   let r = "";
-  const d = [t, o, i];
+  const d = [e, o, i];
   for (let l = 0; l < d.length; l++) {
-    const $ = d[l];
-    if ($.length !== 0)
-      if ($.length === 1)
-        r += `let d${$[0]} = i32(globalId[${l}]);`;
+    const f = d[l];
+    if (f.length !== 0)
+      if (f.length === 1)
+        r += `let d${f[0]} = i32(globalId[${l}]);`;
       else {
-        const h = L($, "uniforms.outShape");
+        const S = L(f, "uniforms.outShape");
         r += `var index${l} = i32(globalId[${l}]);`;
-        for (let c = 0; c < h.length; c++)
-          r += `let d${$[c]} = index${l} / ${h[c]};`, c === h.length - 1 ? r += `let d${$[c + 1]} = index${l} - d${$[c]} * ${h[c]};` : r += `index${l} = index${l} - d${$[c]} * ${h[c]};`;
+        for (let c = 0; c < S.length; c++)
+          r += `let d${f[c]} = index${l} / ${S[c]};`, c === S.length - 1 ? r += `let d${f[c + 1]} = index${l} - d${f[c]} * ${S[c]};` : r += `index${l} = index${l} - d${f[c]} * ${S[c]};`;
       }
   }
   const p = [];
   for (let l = 0; l < n; l++)
     p.push(`d${l}`);
-  const a = v(n);
-  let g = `fn getOutputCoords() -> ${a} {
+  const a = g(n);
+  let v = `fn getOutputCoords() -> ${a} {
   ${r}
 `;
-  return p.length === 0 ? g += `return ${a}(0); }` : g += `return ${a}(${p.join(",")}); }`, g;
+  return p.length === 0 ? v += `return ${a}(0); }` : v += `return ${a}(${p.join(",")}); }`, v;
 }
-function G(e) {
+function R(t) {
   let s = "";
-  switch (e) {
+  switch (t) {
     case 0:
     case 1:
       s += `
@@ -454,66 +460,66 @@ function G(e) {
         `;
       break;
     default:
-      A(!1, () => `Unsupported ${e}D shape`);
+      A(!1, () => `Unsupported ${t}D shape`);
       break;
   }
   return s;
 }
-function F(e) {
-  return e.dispatch[1] === 1 && e.dispatch[2] === 1;
+function _(t) {
+  return t.dispatch[1] === 1 && t.dispatch[2] === 1;
 }
-function x(e, s = 1) {
-  if (e === "float32")
-    return f(s, "f32");
-  if (e === "int32" || e === "bool")
-    return f(s, "i32");
-  throw new Error(`type ${e} is not supported.`);
+function b(t, s = 1) {
+  if (t === "float32")
+    return h(s, "f32");
+  if (t === "int32" || t === "bool" || t === "packedF16")
+    return h(s, "i32");
+  throw new Error(`type ${t} is not supported.`);
 }
-function V(e, s, t) {
-  const o = e.length, i = x(s, t);
-  let u = `fn setOutputAtIndex(flatIndex : i32, value : ${f(t)}) {
+function G(t, s, e) {
+  const o = t.length, i = b(s, e);
+  let u = `fn setOutputAtIndex(flatIndex : i32, value : ${h(e)}) {
       result[flatIndex] = ${i}(value);
     }
 
-    fn setOutputAtIndexI32(flatIndex : i32, value : ${f(t, "i32")}) {
+    fn setOutputAtIndexI32(flatIndex : i32, value : ${h(e, "i32")}) {
       result[flatIndex] = ${i}(value);
     }
     `;
   if (o >= 2) {
-    const n = ["d0", "d1", "d2", "d3", "d4", "d5"].slice(0, o), r = v(o);
+    const n = ["d0", "d1", "d2", "d3", "d4", "d5"].slice(0, o), r = g(o);
     u += `
-      fn setOutputAtCoords(${n.map((d) => `${d} : i32`).join(", ")}, value : ${f(t)}) {
+      fn setOutputAtCoords(${n.map((d) => `${d} : i32`).join(", ")}, value : ${h(e)}) {
         let flatIndex = getOutputIndexFromCoords(${r}(${n.join(", ")}));
-        setOutputAtIndex(flatIndex${t === 1 ? "" : ` / ${t}`}, value);
+        setOutputAtIndex(flatIndex${e === 1 ? "" : ` / ${e}`}, value);
       }
-      fn setOutputAtCoordsI32(${n.map((d) => `${d} : i32`).join(", ")}, value : ${f(t, "i32")}) {
+      fn setOutputAtCoordsI32(${n.map((d) => `${d} : i32`).join(", ")}, value : ${h(e, "i32")}) {
         let flatIndex = getOutputIndexFromCoords(${r}(${n.join(", ")}));
-        setOutputAtIndexI32(flatIndex${t === 1 ? "" : ` / ${t}`}, value);
+        setOutputAtIndexI32(flatIndex${e === 1 ? "" : ` / ${e}`}, value);
       }
     `;
   }
   return u;
 }
-function B(e) {
+function V(t) {
   const s = /(\w+)\s*:\s*vec(5|6)/g;
-  e = e.replace(s, (o) => "@align(16) " + o);
-  const t = /vec(5|6)\s*,\s*(\w+)/g;
-  return e = e.replace(t, (o, i, u) => `vec${i}, @align(16) ${u}`), e;
+  t = t.replace(s, (o) => "@align(16) " + o);
+  const e = /vec(5|6)\s*,\s*(\w+)/g;
+  return t = t.replace(e, (o, i, u) => `vec${i}, @align(16) ${u}`), t;
 }
-function m(e) {
-  return !(e.dispatchLayout.hasOwnProperty("y") && e.dispatchLayout.y.length !== 0 || e.dispatchLayout.hasOwnProperty("z") && e.dispatchLayout.z.length !== 0);
+function k(t) {
+  return !(t.dispatchLayout.hasOwnProperty("y") && t.dispatchLayout.y.length !== 0 || t.dispatchLayout.hasOwnProperty("z") && t.dispatchLayout.z.length !== 0);
 }
 export {
-  b as P,
+  w as P,
   y as a,
-  v as b,
+  g as b,
   I as c,
-  x as d,
-  q as e,
-  Y as f,
+  b as d,
+  Y as e,
+  H as f,
   N as g,
-  H as h,
-  Z as m,
+  X as h,
+  q as m,
   L as s,
-  f as t
+  h as t
 };