@genai-fi/nanogpt 0.7.3 → 0.8.1

package/dist/{index-CLthM0TO.js → index-evZ57wr4.js}

@@ -1,14 +1,14 @@
-import { ac as U, d2 as Jt, d3 as es, e as Te, l as L, d4 as _e, j as $, aL as Ge, al as de, d5 as st, d6 as ts, d7 as ss, aM as os, bg as Ct, a1 as Re, d8 as is, d9 as rs, da as as, bo as ns, k as Z, cd as us, db as ot, am as ds, a6 as ls, u as ge, bf as cs, cl as hs, cm as ps, bm as fs, cn as ms, b5 as gs, ab as ze, p as se, ay as xs, bE as Cs, bF as ws, bG as bs, co as ys, cp as Ss, cq as vs, cs as Is, cr as ks, ct as Rs, U as Ps, c0 as Ds, bH as Ns, bI as $s, cu as zs, cv as As, J as Fs, W as Ls, bK as Es, aP as Bs, dc as Ws, bv as Ts, b2 as _s, bj as Vs, bk as Us, bp as Ms, bM as Os, cx as Gs, aY as Hs, Q as Xs, bN as Ks, c9 as qs, bO as Ys, bP as Qs, cy as js, bQ as Zs, a8 as Js, bR as eo, b6 as to, bS as so, bT as oo, bU as io, dd as ro, bV as ao, cb as no, cc as uo, de as lo, cz as co, cA as ho, cB as po, df as fo, bu as mo, Y as go, aR as xo, as as Co, cC as wo, bq as bo, bW as yo, ae as So, aV as vo, br as Io, dg as ko, b7 as Ro, ak as Po, bs as Do, dh as No, bL as $o, ca as zo, di as Ao, a5 as Fo, G as Lo, aW as Eo, aX as Bo, dj as Wo, cD as To, cE as _o, cF as Vo, an as Uo, aZ as Mo, a_ as Oo, dk as Go, af as Ho, bX as Xo, b0 as Ko, bZ as qo, dl as Yo, cI as Qo, cH as jo, bt as Zo, b_ as Jo, b$ as ei, cJ as ti, cK as si, dm as oi, aS as ii, b1 as ri, cL as ai, cM as ni, S as ui, ad as di, a$ as li, b9 as ci, ba as hi, c1 as pi, cU as fi, c2 as mi, P as gi, a2 as xi, c3 as Ci, cN as wi, ap as bi, bw as yi, R as Si, az as vi, V as Ii, at as ki, au as Ri, bc as Pi, cO as Di, bd as Ni, cP as $i, c5 as zi, b8 as Ai, b3 as Fi, bx as Li, a4 as Ei, dn as Bi, aQ as Wi, c6 as Ti, ar as _i, cQ as Vi, a9 as Ui, c7 as Mi, bY as Oi, c4 as Gi, dp as Hi, dq as Xi, N as Ki, dr as qi, a7 as Yi, L as Qi, bz as ji, cR as Zi, bA as Ji, av as er, ds as tr, dt as sr, bC as or, cS as ir, bJ as rr, du as ar, dv as nr, be as ur, b4 as dr, c8 as lr, f as cr } from "./index-BoWRt-10.js";
-import { m as hr, c as pr, P as He, t as E, g as y, a as J, b as q, d as Pe, e as fr, f as mr } from "./webgpu_program-PFzf1hAQ.js";
-import { i as wt, G as it, a as gr, c as S, f as I, M as j, b as bt, d as yt, e as St } from "./webgpu_util-D____QpY.js";
-import { m as rt, E as xr, u as Cr, w as wr, x as br, y as yr, z as Sr, f as at, A as vt, B as It, C as kt, D as vr, F as Ir, G as xe, H as kr, I as Rr, J as Pr, K as Dr, L as Nr, M as $r, N as zr, O as Ar, P as Fr, Q as Lr, S as Er } from "./backend_util-TE7aTPhZ.js";
-import { S as Br, a as Wr, h as be, i as Ae, p as Tr, q as _r, j as ye, d as ee, e as Xe, g as Ke, k as Rt, B as Vr, C as Ur } from "./selu_util-BJEXVvjX.js";
-import { r as R, a as Mr } from "./Reshape-DvudQDvJ.js";
-import { s as Or } from "./shared-B8ztnyEk.js";
-import { c as qe, g as Se, a as ve, b as Ye, e as Gr, h as Pt } from "./axis_util-BzbKo31C.js";
-import { z as Hr } from "./zeros--BdLQ3oG.js";
+import { ag as U, d4 as Jt, d5 as es, e as We, n as L, d6 as _e, j as $, aO as Ge, ap as de, d7 as st, d8 as ts, d9 as ss, aP as os, bn as Ct, a3 as Re, da as is, db as rs, dc as as, bv as ns, l as Z, cg as us, dd as ot, az as ds, aa as ls, u as ge, bm as cs, co as hs, cp as ps, bt as fs, cq as ms, bc as gs, af as ze, p as se, aB as xs, bJ as Cs, bK as ws, bL as bs, cr as ys, cs as Ss, ct as vs, cv as Is, cu as ks, cw as Rs, ah as Ps, b5 as Ds, bM as Ns, bN as $s, cx as zs, cy as As, U as Fs, $ as Ls, bP as Bs, aS as Es, de as Ts, b7 as Ws, b8 as _s, bq as Vs, br as Us, bw as Ms, bR as Os, cA as Gs, a$ as Hs, I as Xs, bS as Ks, cc as qs, bT as Ys, bU as Qs, cB as js, bV as Zs, ac as Js, bW as eo, bd as to, bX as so, bY as oo, bZ as io, df as ro, b_ as ao, ce as no, cf as uo, dg as lo, cC as co, cD as ho, cE as po, dh as fo, bB as mo, a1 as go, aU as xo, as as Co, cF as wo, bx as bo, b$ as yo, ai as So, aY as vo, by as Io, di as ko, be as Ro, ao as Po, bz as Do, dj as No, bQ as $o, cd as zo, dk as Ao, a8 as Fo, G as Lo, aZ as Bo, a_ as Eo, dl as To, cG as Wo, cH as _o, cI as Vo, at as Uo, b0 as Mo, b1 as Oo, dm as Go, aj as Ho, b2 as Xo, b4 as Ko, c1 as qo, dn as Yo, cL as Qo, cK as jo, bA as Zo, c2 as Jo, c3 as ei, cM as ti, cN as si, dp as oi, aV as ii, b6 as ri, cO as ai, Y as ni, S as ui, a6 as di, b3 as li, bg as ci, bh as hi, c4 as pi, cW as fi, c5 as mi, P as gi, a4 as xi, c6 as Ci, cP as wi, au as bi, bC as yi, R as Si, aC as vi, Z as Ii, _ as ki, av as Ri, bj as Pi, cQ as Di, bk as Ni, cR as $i, c8 as zi, bf as Ai, b9 as Fi, bD as Li, a7 as Bi, dq as Ei, aT as Ti, c9 as Wi, ar as _i, cS as Vi, ad as Ui, ca as Mi, c0 as Oi, c7 as Gi, dr as Hi, ds as Xi, X as Ki, dt as qi, ab as Yi, W as Qi, bF as ji, cT as Zi, ba as Ji, aw as er, du as tr, dv as sr, bH as or, cU as ir, bO as rr, dw as ar, dx as nr, bl as ur, bb as dr, cb as lr, f as cr } from "./index-DdmHGZjq.js";
+import { m as hr, c as pr, P as He, t as B, g as y, a as J, b as q, d as Pe, e as fr, f as mr } from "./webgpu_program-Dhk9R5aG.js";
+import { i as wt, G as it, a as gr, c as S, f as I, M as j, b as bt, d as yt, e as St } from "./webgpu_util-BqGnZg8t.js";
+import { m as rt, E as xr, u as Cr, w as wr, x as br, y as yr, z as Sr, f as at, A as vt, B as It, C as kt, D as vr, F as Ir, G as xe, H as kr, I as Rr, J as Pr, K as Dr, L as Nr, M as $r, N as zr, O as Ar, P as Fr, Q as Lr, S as Br } from "./backend_util-yC3YH1jo.js";
+import { S as Er, a as Tr, h as be, i as Ae, p as Wr, q as _r, j as ye, d as ee, e as Xe, g as Ke, k as Rt, A as Vr, B as Ur } from "./selu_util-BgUO9gHY.js";
+import { r as R, a as Mr } from "./Reshape-41YpQqEo.js";
+import { s as Or } from "./shared-V6D_md-c.js";
+import { c as qe, g as Se, a as ve, b as Ye, e as Gr, h as Pt } from "./axis_util-Did9235A.js";
+import { z as Hr } from "./zeros-Dnwix0p4.js";
 import { n as Xr, a as Kr } from "./non_max_suppression_impl-CsEgBuMA.js";
-import { c as Qe } from "./scatter_nd_util-DUstGbU1.js";
+import { c as Qe } from "./scatter_nd_util-B7yDhiQr.js";
 /**
  * @license
  * Copyright 2019 Google LLC. All Rights Reserved.
@@ -230,7 +230,7 @@ class Fe extends Jt {
   constructor(t, e) {
     if (super(), this.commandQueueOwnedIds = /* @__PURE__ */ new WeakSet(), this.dispatchCountInPass = 0, this.disposed = !1, this.downloadWaitMs = 0, this.tensorDataPendingDisposal = [], this.queryResolveBuffer = null, this.querySet = null, this.querySetCount = 2, this.stagingPendingDisposal = [], this.uniformPendingDisposal = [], this.uploadWaitMs = 0, this.hasReadSyncWarned = !1, this.hasTimestampQueryWarned = !1, !wt())
       throw new Error("WebGPU is not supported on this device");
-    this.pipelineCache = {}, this.device = t, this.queue = t.queue, this.commandEncoder = null, this.computePassEncoder = null, this.adapterInfo = new qr(e), this.supportTimestampQuery = this.device.features.has("timestamp-query"), this.thresholdToIncreaseWorkgroups = this.adapterInfo.intelGPUGeneration >= 12 ? 16 : 8, this.bufferManager = new Yr(this.device), this.textureManager = new Qr(this.device), this.tensorMap = new es(this, Te()), U().getBool("WEBGPU_USE_PROFILE_TOOL") && (this.dummyCanvas = document.createElement("canvas"), this.dummyCanvas.width = 1, this.dummyCanvas.height = 1, this.dummyContext = this.dummyCanvas.getContext("webgpu"), this.dummyContext.configure({
+    this.pipelineCache = {}, this.device = t, this.queue = t.queue, this.commandEncoder = null, this.computePassEncoder = null, this.adapterInfo = new qr(e), this.supportTimestampQuery = this.device.features.has("timestamp-query"), this.thresholdToIncreaseWorkgroups = this.adapterInfo.intelGPUGeneration >= 12 ? 16 : 8, this.bufferManager = new Yr(this.device), this.textureManager = new Qr(this.device), this.tensorMap = new es(this, We()), U().getBool("WEBGPU_USE_PROFILE_TOOL") && (this.dummyCanvas = document.createElement("canvas"), this.dummyCanvas.width = 1, this.dummyCanvas.height = 1, this.dummyContext = this.dummyCanvas.getContext("webgpu"), this.dummyContext.configure({
       device: t,
       format: "bgra8unorm"
     }), document.body.appendChild(this.dummyCanvas));
@@ -351,28 +351,28 @@ class Fe extends Jt {
         alphaMode: r[g]
       }), x.getCurrentTexture();
     }).map((m, g) => {
-      const x = h * 4, C = (A, z, B) => {
+      const x = h * 4, C = (A, z, E) => {
         this.ensureCommandEncoderReady(), this.commandEncoder.copyBufferToTexture({
           buffer: a,
           bytesPerRow: x,
-          offset: B
+          offset: E
         }, {
           texture: m
         }, {
           width: A,
           height: z
         }), this.submitQueue();
-        const W = p.getContext("2d", {
+        const T = p.getContext("2d", {
           willReadFrequently: !0
         });
-        W.clearRect(0, 0, A, z), W.drawImage(c[g], 0, 0);
-        const G = W.getImageData(0, 0, A, z).data, M = r[g], T = new Uint8ClampedArray(d, B, A * z * 4);
-        for (let V = 0; V < T.length; V += 4)
+        T.clearRect(0, 0, A, z), T.drawImage(c[g], 0, 0);
+        const G = T.getImageData(0, 0, A, z).data, M = r[g], W = new Uint8ClampedArray(d, E, A * z * 4);
+        for (let V = 0; V < W.length; V += 4)
           if (M === "premultiplied")
-            T[V + 3] = G[V + 3];
+            W[V + 3] = G[V + 3];
           else {
             const O = G[V];
-            T[V] = G[V + 2], T[V + 1] = G[V + 1], T[V + 2] = O;
+            W[V] = G[V + 2], W[V + 1] = G[V + 1], W[V + 2] = O;
           }
       }, w = Math.floor(u / (h * l));
       let v = h, k = l, P = 0;
@@ -429,7 +429,7 @@ class Fe extends Jt {
       throw new Error(`GPUBuffer size(${t.buffer.size}) is smaller than tensor size(${n})!`);
     if ((t.buffer.usage & (GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC)) !== (GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC))
       throw new Error("GPUBuffer.usage should include GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC!");
-    return t.zeroCopy !== !0 && (s = this.copyBuffer(s)), a.resource = s, Te().makeTensorFromDataId(r, e, o, this);
+    return t.zeroCopy !== !0 && (s = this.copyBuffer(s)), a.resource = s, We().makeTensorFromDataId(r, e, o, this);
   }
   /**
    * Read tensor to a new GPUBuffer.
@@ -443,7 +443,7 @@ class Fe extends Jt {
       throw o != null ? new Error("Data is not on GPU but on CPU.") : new Error("There is no data on GPU or CPU.");
     const n = a, u = n.size, d = n.usage, h = this.bufferManager.acquireBuffer(u, d);
     this.ensureCommandEncoderReady(), this.endComputePassEncoder(), this.commandEncoder.copyBufferToBuffer(a, 0, h, 0, u), this.submitQueue();
-    const l = this.makeTensorInfo(r, s), c = Te().makeTensorFromTensorInfo(l), p = this.tensorMap.get(l.dataId);
+    const l = this.makeTensorInfo(r, s), c = We().makeTensorFromTensorInfo(l), p = this.tensorMap.get(l.dataId);
     return p.resource = h, { tensorRef: c, buffer: h };
   }
   bufferSync(t) {
@@ -920,10 +920,10 @@ const Da = "return abs(a);", Na = `
     return -uniforms.INFINITY;
   }
   return atanh(a);
-`, Ea = "return ceil(a);", Ba = "return cos(a);", Wa = `
+`, Ba = "return ceil(a);", Ea = "return cos(a);", Ta = `
   let e2x = exp(-a);
   return (e2x + 1.0 / e2x) / 2.0;
-`, Ta = "return exp(a) - 1.0;", _a = "if (a >= 0.0) { return a; }  return (exp(a) - 1.0);", Va = `
+`, Wa = "return exp(a) - 1.0;", _a = "if (a >= 0.0) { return a; }  return (exp(a) - 1.0);", Va = `
   var resFloat = exp(a) - vec4<f32>(1.0);
   if (a.r >= 0.0) {
     resFloat.r = a.r;
@@ -964,9 +964,9 @@ const Da = "return abs(a);", Na = `
   return select(a, vec4<f32>(0.0), a < vec4<f32>(0.0));
 `, an = "return round(a);", nn = "return inverseSqrt(a);", un = `
   if (a >= 0.0) {
-    return ${Br} * a;
+    return ${Er} * a;
   } else {
-    return ${Wr} * (exp(a) - 1.0);
+    return ${Tr} * (exp(a) - 1.0);
   }
 `, dn = "return 1.0 / (1.0 + exp(-1.0 * a));", ln = "return sign(a);", cn = "return sin(a);", hn = `
   let e2x = exp(a);
@@ -1013,11 +1013,11 @@ function te(i, t) {
     case b.ATANH:
       return La;
     case b.COS:
-      return Ba;
+      return Ea;
     case b.COSH:
-      return Wa;
+      return Ta;
     case b.CEIL:
-      return Ea;
+      return Ba;
     case b.ELU:
       return t ? Va : _a;
     case b.ERF:
@@ -1025,7 +1025,7 @@ function te(i, t) {
     case b.EXP:
       return Ma;
     case b.EXPM1:
-      return Ta;
+      return Wa;
     case b.FLOOR:
       return Oa;
     case b.IS_FINITE:
@@ -1120,7 +1120,7 @@ function Q(i, t = !1, e = !1, o = 3) {
     s = te(b.LEAKYRELU, e);
   else
     throw new Error(`Activation ${i} has not been implemented for the WebGPU backend.`);
-  const a = E(e ? 4 : 1);
+  const a = B(e ? 4 : 1);
   let n = "";
   return t ? n = `
       fn activation(a : ${a}, coords : vec${o}<i32>) -> ${a} {
@@ -1160,8 +1160,8 @@ function Dt(i, t, e = !1, o = !1, s = !1, r = 1) {
 
     `, n = t ? "value = getB(batch, col, row);" : "value = getB(batch, row, col);";
   return `
-  fn mm_readA(batch: i32, row: i32, col: i32) -> ${E(r)} {
-    var value = ${E(r)}(0.0);
+  fn mm_readA(batch: i32, row: i32, col: i32) -> ${B(r)} {
+    var value = ${B(r)}(0.0);
     ${e && s ? a : `
     ${i ? "if(row < uniforms.dimAOuter && col < uniforms.dimInner)" : "if(row < uniforms.aShape[1] && col < uniforms.aShape[2])"}
     {
@@ -1171,8 +1171,8 @@ function Dt(i, t, e = !1, o = !1, s = !1, r = 1) {
     return value;
   }
 
-  fn mm_readB(batch: i32, row: i32, col: i32) -> ${E(r)} {
-    var value = ${E(r)}(0.0);
+  fn mm_readB(batch: i32, row: i32, col: i32) -> ${B(r)} {
+    var value = ${B(r)}(0.0);
     ${n}
     return value;
   }
@@ -1181,7 +1181,7 @@ function Dt(i, t, e = !1, o = !1, s = !1, r = 1) {
 function Ze(i, t, e, o, s = !1, r = !1, a = !1, n = 1) {
   return `
   ${Dt(e, o, s, r, a, n)}
-  fn mm_write(batch: i32, row: i32, col: i32, valueIn: ${E(n)}) {
+  fn mm_write(batch: i32, row: i32, col: i32, valueIn: ${B(n)}) {
     ${s && r ? "" : "if (row < uniforms.dimAOuter && col < uniforms.dimBOuter)"}
     {
       var value = valueIn;
@@ -1287,7 +1287,7 @@ const lt = (i) => i ? `
           globalRowStart + inputRow,
           kStart + inputCol);
         `, Sn = (i) => i ? "let ACached = mm_Asub[k][tileRow + innerRow];" : "let ACached = mm_Asub[tileRow + innerRow][k];";
-function Ee(i, t, e = !1, o = 32, s = !1, r = 32, a = !1, n = !1) {
+function Be(i, t, e = !1, o = 32, s = !1, r = 32, a = !1, n = !1) {
   const u = i[1] * t[1], d = i[0] * t[0], h = e ? u : o, l = e ? o : u;
   L(l % t[1] === 0 && h % t[0] === 0 && o % t[1] === 0, () => `tileAHight ${l} must be divisible by workgroupSize[1]${t[1]}, tileAWidth ${h} must be divisible by workgroupSize[0]${t[0]}, tileInner ${o} must be divisible by workgroupSize[1]${t[1]}`);
   const c = l / t[1], p = h / t[0], f = o / t[1], m = i[1], g = i[0], x = a ? `
@@ -1501,7 +1501,7 @@ class kn {
     return `
       ${Q(this.activation, this.hasPreluActivationWeights, this.isVec4)}
       ${Ze(this.addBias, this.activation, !1, this.transposeB, this.fitAOuter, this.fitBOuter, this.fitInner, this.isVec4 ? 4 : 1)}
-      ${this.isVec4 ? Le(this.elementsPerThread, this.workgroupSize, this.transposeA, this.tileInner, !1, null, !0) : this.isVectorA ? In(this.workgroupSize, this.transposeA) : Ee(this.elementsPerThread, this.workgroupSize, this.transposeA, this.tileInner, !1, null, this.sequentialAccessByThreads, !0)}
+      ${this.isVec4 ? Le(this.elementsPerThread, this.workgroupSize, this.transposeA, this.tileInner, !1, null, !0) : this.isVectorA ? In(this.workgroupSize, this.transposeA) : Be(this.elementsPerThread, this.workgroupSize, this.transposeA, this.tileInner, !1, null, this.sequentialAccessByThreads, !0)}
     `;
   }
 }
@@ -1694,7 +1694,7 @@ class $n {
     const t = this.outputComponent;
     return `
       ${Dt(!1, this.transposeB, !1, !1, !1, t)}
-      fn mm_write(batch: i32, row : i32, col : i32, value : ${E(t)}) {
+      fn mm_write(batch: i32, row : i32, col : i32, value : ${B(t)}) {
         if (row < uniforms.dimAOuter && col < uniforms.dimBOuter) {
           let coords = vec3<i32>(batch, row, col);
           let flatIndex = getOutputIndexFromCoords(coords);
@@ -1705,7 +1705,7 @@ class $n {
           }
         }
       }
-      ${t === 4 ? Le(this.elementsPerThread, this.workgroupSize, this.transposeA, 32, !0, this.splitedDimInner) : Ee(this.elementsPerThread, this.workgroupSize, this.transposeA, 32, !0, this.splitedDimInner)}
+      ${t === 4 ? Le(this.elementsPerThread, this.workgroupSize, this.transposeA, 32, !0, this.splitedDimInner) : Be(this.elementsPerThread, this.workgroupSize, this.transposeA, 32, !0, this.splitedDimInner)}
     `;
   }
 }
@@ -1805,34 +1805,34 @@ const Fn = {
  * limitations under the License.
  * =============================================================================
  */
-function Be({ a: i, b: t, transposeA: e, transposeB: o, backend: s, bias: r = null, preluActivationWeights: a = null, leakyreluAlpha: n = 0, activation: u = null }) {
+function Ee({ a: i, b: t, transposeA: e, transposeB: o, backend: s, bias: r = null, preluActivationWeights: a = null, leakyreluAlpha: n = 0, activation: u = null }) {
   const d = i.shape.length, h = t.shape.length, l = e ? i.shape[d - 2] : i.shape[d - 1], c = o ? t.shape[h - 1] : t.shape[h - 2], p = e ? i.shape[d - 1] : i.shape[d - 2], f = o ? t.shape[h - 2] : t.shape[h - 1], m = i.shape.slice(0, -2), g = t.shape.slice(0, -2), x = $(m), C = $(g), v = Z(i.shape.slice(0, -2), t.shape.slice(0, -2)).concat([p, f]);
   L(l === c, () => `Error in matMul: inner shapes (${l}) and (${c}) of Tensors with shapes ${i.shape} and ${t.shape} and transposeA=${e} and transposeB=${o} must match.`);
-  const k = e ? [x, l, p] : [x, p, l], P = o ? [C, f, c] : [C, c, f], N = R({ inputs: { x: i }, backend: s, attrs: { shape: k } }), A = R({ inputs: { x: t }, backend: s, attrs: { shape: P } }), z = [N, A], B = Math.max(x, C), W = [N, A], G = [
+  const k = e ? [x, l, p] : [x, p, l], P = o ? [C, f, c] : [C, c, f], N = R({ inputs: { x: i }, backend: s, attrs: { shape: k } }), A = R({ inputs: { x: t }, backend: s, attrs: { shape: P } }), z = [N, A], E = Math.max(x, C), T = [N, A], G = [
     { type: "int32", data: [p] },
     { type: "int32", data: [f] },
     { type: "int32", data: [l] }
   ];
-  let M, T;
-  const V = [B, p, f];
+  let M, W;
+  const V = [E, p, f];
   let O = U().get("WEBGPU_MATMUL_PROGRAM_TYPE");
   if (O < 0) {
-    const ae = U().getNumber("WEBGPU_THRESHOLD_TO_INCREASE_WORKGROUPS_FOR_MATMUL"), he = ae > 0 ? ae : s.thresholdToIncreaseWorkgroups, pe = B * Math.ceil(p / 32) * Math.ceil(f / 32);
-    pe <= he || p <= 8 && pe <= he * 2 ? B * p * f <= 128 ? O = j.MatMulReduceProgram : B === 1 && c >= 2e3 ? O = j.MatMulSplitKProgram : O = j.MatMulSmallOutputSizeProgram : O = j.MatMulPackedProgram;
+    const ae = U().getNumber("WEBGPU_THRESHOLD_TO_INCREASE_WORKGROUPS_FOR_MATMUL"), he = ae > 0 ? ae : s.thresholdToIncreaseWorkgroups, pe = E * Math.ceil(p / 32) * Math.ceil(f / 32);
+    pe <= he || p <= 8 && pe <= he * 2 ? E * p * f <= 128 ? O = j.MatMulReduceProgram : E === 1 && c >= 2e3 ? O = j.MatMulSplitKProgram : O = j.MatMulSmallOutputSizeProgram : O = j.MatMulPackedProgram;
   }
   switch (O) {
     case j.MatMulReduceProgram:
       M = new Pn(V, e, o, r, u, a);
       break;
     case j.MatMulSplitKProgram: {
-      if (T = H({ backend: s, attrs: { shape: V, value: 0, dtype: i.dtype } }), M = new $n(V, c, e, o), r || u) {
-        T = s.runWebGPUProgram(M, W, i.dtype, G, T);
-        const he = new zn(T.shape, r, u, a);
+      if (W = H({ backend: s, attrs: { shape: V, value: 0, dtype: i.dtype } }), M = new $n(V, c, e, o), r || u) {
+        W = s.runWebGPUProgram(M, T, i.dtype, G, W);
+        const he = new zn(W.shape, r, u, a);
         let pe = null;
-        const ke = [T];
+        const ke = [W];
         r && ke.push(r), a && ke.push(a), u === "leakyrelu" && (pe = [{ type: "float32", data: [n] }], he.uniforms += " alpha : f32,");
-        const tt = s.runWebGPUProgram(he, ke, T.dtype, pe);
-        z.push(T);
+        const tt = s.runWebGPUProgram(he, ke, W.dtype, pe);
+        z.push(W);
         const jt = R({ inputs: { x: tt }, backend: s, attrs: { shape: v } });
         z.push(tt);
         for (const Zt of z)
@@ -1851,9 +1851,9 @@ function Be({ a: i, b: t, transposeA: e, transposeB: o, backend: s, bias: r = nu
     default:
       throw new Error(`Unsupported MatMulProgramType ${O}.`);
   }
-  r && W.push(r), a && W.push(a), u === "leakyrelu" && (G.push({ type: "float32", data: [n] }), M.uniforms += " alpha : f32,"), T = s.runWebGPUProgram(M, W, i.dtype, G, T);
-  const Qt = R({ inputs: { x: T }, backend: s, attrs: { shape: v } });
-  z.push(T);
+  r && T.push(r), a && T.push(a), u === "leakyrelu" && (G.push({ type: "float32", data: [n] }), M.uniforms += " alpha : f32,"), W = s.runWebGPUProgram(M, T, i.dtype, G, W);
+  const Qt = R({ inputs: { x: W }, backend: s, attrs: { shape: v } });
+  z.push(W);
   for (const ae of z)
     s.disposeData(ae.dataId);
   return Qt;
@@ -1876,7 +1876,7 @@ function Be({ a: i, b: t, transposeA: e, transposeB: o, backend: s, bias: r = nu
  */
 function Ln(i) {
   const { inputs: t, backend: e, attrs: o } = i, { a: s, b: r, bias: a, preluActivationWeights: n } = t, { transposeA: u, transposeB: d, activation: h, leakyreluAlpha: l } = o;
-  return Be({
+  return Ee({
     a: s,
     b: r,
     transposeA: u,
@@ -1888,7 +1888,7 @@ function Ln(i) {
     activation: h
   });
 }
-const En = {
+const Bn = {
   kernelName: us,
   backendName: "webgpu",
   kernelFunc: Ln
@@ -2022,7 +2022,7 @@ function X(i) {
   const { inputs: t } = i, { x: e } = t;
   return i.backend.incRef(e.dataId), { dataId: e.dataId, shape: e.shape, dtype: e.dtype };
 }
-const Bn = {
+const En = {
   kernelName: ds,
   backendName: "webgpu",
   kernelFunc: X
@@ -2047,7 +2047,7 @@ function ie(i) {
   const { inputs: t, backend: e } = i, { real: o, imag: s } = t, r = e.makeTensorInfo(o.shape, "complex64"), a = e.tensorMap.get(r.dataId), n = X({ inputs: { x: o }, backend: e }), u = X({ inputs: { x: s }, backend: e });
   return a.complexTensorInfos = { real: n, imag: u }, r;
 }
-const Wn = {
+const Tn = {
   kernelName: ls,
   backendName: "webgpu",
   kernelFunc: ie
@@ -2196,7 +2196,7 @@ function _({ opType: i, cpuKernelImpl: t, supportsComplex: e = !1, dtype: o }) {
  * limitations under the License.
  * =============================================================================
  */
-const { addImpl: Tn, castImpl: _n, ceilImpl: Vn, concatImpl: Un, equalImpl: Mn, expImpl: On, expm1Impl: Gn, floorImpl: Hn, floorDivImpl: Xn, gatherNdImpl: Kn, gatherV2Impl: qn, greaterEqualImpl: Yn, greaterImpl: Qn, lessEqualImpl: jn, lessImpl: Zn, logImpl: Jn, maxImpl: eu, maximumImpl: tu, minimumImpl: su, multiplyImpl: ou, negImpl: iu, notEqualImpl: ru, prodImpl: au, rangeImpl: nu, rsqrtImpl: uu, scatterImpl: du, simpleAbsImpl: lu, sliceImpl: cu, stridedSliceImpl: hu, stringNGramsImpl: pu, subImpl: fu, tileImpl: mu, topKImpl: gu, transposeImpl: xu } = Or;
+const { addImpl: Wn, castImpl: _n, ceilImpl: Vn, concatImpl: Un, equalImpl: Mn, expImpl: On, expm1Impl: Gn, floorImpl: Hn, floorDivImpl: Xn, gatherNdImpl: Kn, gatherV2Impl: qn, greaterEqualImpl: Yn, greaterImpl: Qn, lessEqualImpl: jn, lessImpl: Zn, logImpl: Jn, maxImpl: eu, maximumImpl: tu, minimumImpl: su, multiplyImpl: ou, negImpl: iu, notEqualImpl: ru, prodImpl: au, rangeImpl: nu, rsqrtImpl: uu, scatterImpl: du, simpleAbsImpl: lu, sliceImpl: cu, stridedSliceImpl: hu, stringNGramsImpl: pu, subImpl: fu, tileImpl: mu, topKImpl: gu, transposeImpl: xu } = Or;
 /**
  * @license
  * Copyright 2021 Google LLC. All Rights Reserved.
@@ -2276,7 +2276,7 @@ const Su = F({ opType: b.ACOSH }), vu = {
  * limitations under the License.
  * =============================================================================
  */
-const Iu = _({ opType: D.ADD, cpuKernelImpl: Tn, supportsComplex: !0 }), ku = {
+const Iu = _({ opType: D.ADD, cpuKernelImpl: Wn, supportsComplex: !0 }), ku = {
   kernelName: fs,
   backendName: "webgpu",
   kernelFunc: Iu
@@ -2638,7 +2638,7 @@ function Lu(i) {
   const { inputs: t, backend: e, attrs: o } = i, { x: s } = t, { keepDims: r, axis: a } = o;
   return re(s, a, r, "all", e);
 }
-const Eu = {
+const Bu = {
   kernelName: Cs,
   backendName: "webgpu",
   kernelFunc: Lu
@@ -2659,14 +2659,14 @@ const Eu = {
  * limitations under the License.
  * =============================================================================
  */
-function Bu(i) {
+function Eu(i) {
   const { inputs: t, backend: e, attrs: o } = i, { x: s } = t, { keepDims: r, axis: a } = o;
   return re(s, a, r, "any", e);
 }
-const Wu = {
+const Tu = {
   kernelName: ws,
   backendName: "webgpu",
-  kernelFunc: Bu
+  kernelFunc: Eu
 };
 /**
  * @license
@@ -2787,7 +2787,7 @@ class $t {
  * limitations under the License.
  * =============================================================================
  */
-function Tu(i) {
+function Wu(i) {
   const { inputs: t, backend: e, attrs: o } = i, { x: s } = t, { axis: r } = o;
   let a = se(r, s.shape);
   const n = Se(a, s.shape.length);
@@ -2800,7 +2800,7 @@ function Tu(i) {
 const _u = {
   kernelName: bs,
   backendName: "webgpu",
-  kernelFunc: Tu
+  kernelFunc: Wu
 };
 /**
  * @license
@@ -3512,7 +3512,7 @@ const ld = {
  */
 function cd(i) {
   const { inputs: t, backend: e, attrs: o } = i, { a: s, b: r } = t, { transposeA: a, transposeB: n } = o;
-  return Be({ a: s, b: r, transposeA: a, transposeB: n, backend: e });
+  return Ee({ a: s, b: r, transposeA: a, transposeB: n, backend: e });
 }
 const hd = {
   kernelName: Fs,
@@ -3580,7 +3580,7 @@ function fd(i) {
  * =============================================================================
  */
 function ce(i) {
-  const { inputs: t, backend: e, attrs: o } = i, { x: s } = t, { begin: r, size: a } = o, [n, u] = Tr(s, r, a);
+  const { inputs: t, backend: e, attrs: o } = i, { x: s } = t, { begin: r, size: a } = o, [n, u] = Wr(s, r, a);
   if (_r(s, n, u), e.shouldExecuteOnCPU([s]) || s.dtype === "string") {
     const l = e.tensorMap.get(s.dataId), c = cu(l.values, n, u, s.shape, s.dtype);
     return e.makeTensorInfo(u, s.dtype, c);
@@ -3625,7 +3625,7 @@ const gd = (i) => {
   });
   return p.push(f), p.push(m), p.push(g), p.forEach((C) => e.disposeData(C.dataId)), x;
 }, xd = {
-  kernelName: Es,
+  kernelName: Bs,
   backendName: "webgpu",
   kernelFunc: gd
 };
@@ -3701,7 +3701,7 @@ function bd(i) {
   return e.runWebGPUProgram(p, m, l, f, c);
 }
 const yd = {
-  kernelName: Bs,
+  kernelName: Es,
   backendName: "webgpu",
   kernelFunc: bd
 };
@@ -3780,7 +3780,7 @@ function vd(i) {
   return e.runWebGPUProgram(u, [o, s], "int32", d);
 }
 const Id = {
-  kernelName: Ws,
+  kernelName: Ts,
   backendName: "webgpu",
   kernelFunc: vd
 };
@@ -3800,14 +3800,14 @@ const Id = {
  * limitations under the License.
  * =============================================================================
  */
-const Et = _({
+const Bt = _({
   opType: D.NOT_EQUAL,
   dtype: "bool",
   cpuKernelImpl: ru
 }), kd = {
-  kernelName: Ts,
+  kernelName: Ws,
   backendName: "webgpu",
-  kernelFunc: Et
+  kernelFunc: Bt
 };
 /**
  * @license
@@ -3893,7 +3893,7 @@ function Me(i) {
   if (r === "int32")
     return Pd(s, e);
   if (r === "bool") {
-    const a = e.makeTensorInfo([], "bool", Ct("bool", 1)), u = Et({ inputs: { a: s, b: a }, backend: e });
+    const a = e.makeTensorInfo([], "bool", Ct("bool", 1)), u = Bt({ inputs: { a: s, b: a }, backend: e });
     return e.disposeData(a.dataId), u;
   }
   throw new Error(`Error in Cast: failed to cast ${s.dtype} to ${r}`);
@@ -4039,7 +4039,7 @@ const Ld = {
  * limitations under the License.
  * =============================================================================
  */
-class Ed {
+class Bd {
   constructor(t) {
     this.outputShape = [], this.variableNames = ["real", "imag"], this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = t, this.dispatchLayout = I(this.outputShape), this.dispatch = S(this.dispatchLayout, this.outputShape, this.workgroupSize), this.shaderKey = "complexAbs";
   }
@@ -4082,17 +4082,17 @@ function ht(i, t) {
     shape: i.shape
   };
 }
-function Bd(i) {
-  const { inputs: t, backend: e } = i, { x: o } = t, s = e.tensorMap.get(o.dataId), r = new Ed(o.shape), a = [
+function Ed(i) {
+  const { inputs: t, backend: e } = i, { x: o } = t, s = e.tensorMap.get(o.dataId), r = new Bd(o.shape), a = [
     ht(o, s.complexTensorInfos.real),
     ht(o, s.complexTensorInfos.imag)
   ];
   return e.runWebGPUProgram(r, a, a[0].dtype);
 }
-const Wd = {
+const Td = {
   kernelName: Gs,
   backendName: "webgpu",
-  kernelFunc: Bd
+  kernelFunc: Ed
 };
 /**
  * @license
@@ -4110,7 +4110,7 @@ const Wd = {
  * limitations under the License.
  * =============================================================================
  */
-class Td {
+class Wd {
   constructor(t) {
     this.uniforms = "", this.workPerThread = 1, this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = xe(
       t,
@@ -4164,14 +4164,14 @@ class Td {
  * limitations under the License.
  * =============================================================================
  */
-function We(i) {
+function Te(i) {
   const { inputs: t, backend: e } = i, { input: o } = t, s = e.tensorMap.get(o.dataId);
   return X({ inputs: { x: s.complexTensorInfos.imag }, backend: e });
 }
 const _d = {
   kernelName: Hs,
   backendName: "webgpu",
-  kernelFunc: We
+  kernelFunc: Te
 };
 /**
  * @license
@@ -4192,7 +4192,7 @@ const _d = {
 function fe(i, t, e) {
   const o = i[0].dtype;
   if (o === "complex64") {
-    const f = i.map((w) => Ie({ inputs: { input: w }, backend: e })), m = i.map((w) => We({ inputs: { input: w }, backend: e })), g = fe(f, t, e), x = fe(m, t, e), C = ie({ inputs: { real: g, imag: x }, backend: e });
+    const f = i.map((w) => Ie({ inputs: { input: w }, backend: e })), m = i.map((w) => Te({ inputs: { input: w }, backend: e })), g = fe(f, t, e), x = fe(m, t, e), C = ie({ inputs: { real: g, imag: x }, backend: e });
     return f.forEach((w) => e.disposeData(w.dataId)), m.forEach((w) => e.disposeData(w.dataId)), e.disposeData(g.dataId), e.disposeData(x.dataId), C;
   }
   let s = e.shouldExecuteOnCPU(i);
@@ -4219,7 +4219,7 @@ function fe(i, t, e) {
       e.disposeData(g.dataId);
     return m;
   }
-  const { tensors2D: a, outShape: n } = Vd(i, t, e), u = a.map((f) => f.shape), d = new Td(u), h = [], l = new Array(u.length - 1);
+  const { tensors2D: a, outShape: n } = Vd(i, t, e), u = a.map((f) => f.shape), d = new Wd(u), h = [], l = new Array(u.length - 1);
   if (l.length > 0) {
     l[0] = u[0][1], h.push({ type: "int32", data: [l[0]] });
     for (let f = 1; f < l.length; f++)
@@ -4259,7 +4259,7 @@ function Vd(i, t, e) {
  * limitations under the License.
  * =============================================================================
  */
-function Bt(i) {
+function Et(i) {
   const { inputs: t, backend: e, attrs: o } = i, { axis: s } = o, r = se(s, t[0].shape)[0], a = t.map((d) => d.shape);
   kr(a, r);
   const n = xe(t.map((d) => d.shape), r);
@@ -4271,7 +4271,7 @@ function Bt(i) {
 const Ud = {
   kernelName: Xs,
   backendName: "webgpu",
-  kernelFunc: Bt
+  kernelFunc: Et
 };
 /**
  * @license
@@ -4337,7 +4337,7 @@ function Md(i, t, e, o, s = !1, r = null, a = !1, n = 4, u = 4, d = 4) {
       let xRow = outRow * uniforms.strides[0] + uniforms.dilations[0] * WRow - uniforms.pads[0];
       let xCol = outCol * uniforms.strides[1] + uniforms.dilations[1] * WCol - uniforms.pads[1];
       let xCh = ${x} % inChannels;
-      var resData = ${E(n)}(0.0);
+      var resData = ${B(n)}(0.0);
       // The bounds checking is always needed since we use it to pad zero for
       // the 'same' padding type.
       if (xRow >= 0 && xRow < ${f} && xCol >= 0 && xCol < ${m}) {
@@ -4350,12 +4350,12 @@ function Md(i, t, e, o, s = !1, r = null, a = !1, n = 4, u = 4, d = 4) {
       if (row < uniforms.dimAOuter && col < uniforms.dimInner) {
         ${C}
       }
-      return ${E(n)}(0.0);` : o && e ? `
+      return ${B(n)}(0.0);` : o && e ? `
       ${C}` : `
       if (row < uniforms.dimInner && col < uniforms.dimBOuter) {
         ${C}
       }
-      return ${E(n)}(0.0);`, v = `${l(u)}`, k = E(d), P = i ? E(n) : E(u), N = i ? E(u) : E(n);
+      return ${B(n)}(0.0);`, v = `${l(u)}`, k = B(d), P = i ? B(n) : B(u), N = i ? B(u) : B(n);
   return `
       ${Q(r, a, d === 4, 4)}
       fn mm_readA(batch: i32, row : i32, col : i32) -> ${P} {
@@ -4382,7 +4382,7 @@ class Od {
     this.variableNames = ["x", "W"], this.uniforms = "filterDims : vec2<i32>, pads : vec2<i32>, strides : vec2<i32>, dilations : vec2<i32>, dimAOuter : i32, dimBOuter : i32, dimInner : i32,", this.outputShape = t.outShape, this.isChannelsLast = t.dataFormat === "channelsLast", this.isVec4 = ((t.inChannels % 4 === 0 || t.inChannels % 3 === 0) && this.isChannelsLast || t.outWidth % 4 === 0 && !this.isChannelsLast) && t.outChannels % 4 === 0, this.dispatchLayout = this.isChannelsLast ? { x: [3], y: [1, 2], z: [0] } : { x: [2, 3], y: [1], z: [0] }, this.workgroupSize = yt(this.dispatchLayout, this.outputShape, this.isVec4), this.elementsPerThread = St(this.dispatchLayout, this.outputShape, this.isVec4), this.dispatch = S(this.dispatchLayout, this.outputShape, this.workgroupSize, this.elementsPerThread), this.isVec4 ? (this.outputComponent = 4, this.isChannelsLast && t.inChannels % 4 !== 0 ? (this.innerElementSize = 3, this.variableComponents = [1, 4]) : (this.innerElementSize = 4, this.variableComponents = [4, 4]), r && (this.variableNames.push("bias"), this.variableComponents.push(4)), n && (this.variableNames.push("preluActivationWeights"), this.variableComponents.push(4))) : (this.innerElementSize = this.elementsPerThread[0], r && this.variableNames.push("bias"), n && this.variableNames.push("preluActivationWeights")), this.sequentialAccessByThreads = u, this.addBias = r, this.activation = a, this.hasPreluActivationWeights = n, this.tileAOuter = this.workgroupSize[1] * this.elementsPerThread[1], this.tileBOuter = this.workgroupSize[0] * this.elementsPerThread[0], this.tileInner = Math.max(this.workgroupSize[0] * this.innerElementSize, this.workgroupSize[1]), this.fitAOuter = e % this.tileAOuter === 0, this.fitBOuter = o % this.tileBOuter === 0, this.fitInner = s % this.tileInner === 0, this.shaderKey = `conv2DMM_${this.elementsPerThread}_${this.activation}}_${this.fitAOuter}_${this.fitBOuter}_${this.fitInner}_${this.isVec4}_${this.innerElementSize}_${this.isChannelsLast}_${this.sequentialAccessByThreads}`;
   }
   getUserCode() {
-    const t = this.isVec4 ? Le(this.elementsPerThread, this.workgroupSize, !this.isChannelsLast, this.tileInner) : Ee(this.elementsPerThread, this.workgroupSize, !this.isChannelsLast, this.tileInner, !1, null, this.sequentialAccessByThreads), e = this.isVec4 ? [this.innerElementSize, 4, 4] : [1, 1, 1];
+    const t = this.isVec4 ? Le(this.elementsPerThread, this.workgroupSize, !this.isChannelsLast, this.tileInner) : Be(this.elementsPerThread, this.workgroupSize, !this.isChannelsLast, this.tileInner, !1, null, this.sequentialAccessByThreads), e = this.isVec4 ? [this.innerElementSize, 4, 4] : [1, 1, 1];
     return `
     ${Md(this.isChannelsLast, this.fitAOuter, this.fitBOuter, this.fitInner, this.addBias, this.activation, this.hasPreluActivationWeights, e[0], e[1], e[2])}
     ${t}
@@ -4584,7 +4584,7 @@ function Xd({ x: i, filter: t, convInfo: e, backend: o, bias: s = null, preluAct
     const x = Ne(s.shape, u);
     x != null && (s = R({ inputs: { x: s }, backend: o, attrs: { shape: x } }), c.push(s));
   }
-  const m = Be({
+  const m = Ee({
     a: u ? p : f,
     b: u ? f : p,
     transposeA: d,
@@ -4608,24 +4608,24 @@ function Kd({ x: i, filter: t, convInfo: e, backend: o, bias: s = null, preluAct
     { type: "int32", data: [f] },
     { type: "int32", data: [h * u] },
     { type: "int32", data: [h] }
-  ], z = o.runWebGPUProgram(N, [i], i.dtype, A), B = [];
-  B.push(z);
-  const W = R({ inputs: { x: t }, backend: o, attrs: { shape: [1, v, -1] } });
-  if (B.push(W), r != null) {
+  ], z = o.runWebGPUProgram(N, [i], i.dtype, A), E = [];
+  E.push(z);
+  const T = R({ inputs: { x: t }, backend: o, attrs: { shape: [1, v, -1] } });
+  if (E.push(T), r != null) {
     const O = Ne(r.shape, w);
     O != null && (r = R({
       inputs: { x: r },
       backend: o,
       attrs: { shape: O }
-    }), B.push(r));
+    }), E.push(r));
   }
   if (s != null) {
     const O = Ne(s.shape, w);
-    O != null && (s = R({ inputs: { x: s }, backend: o, attrs: { shape: O } }), B.push(s));
+    O != null && (s = R({ inputs: { x: s }, backend: o, attrs: { shape: O } }), E.push(s));
   }
-  const T = Be({
-    a: w ? z : W,
-    b: w ? W : z,
+  const W = Ee({
+    a: w ? z : T,
+    b: w ? T : z,
     transposeA: !w,
     transposeB: !1,
     backend: o,
@@ -4633,13 +4633,13 @@ function Kd({ x: i, filter: t, convInfo: e, backend: o, bias: s = null, preluAct
     activation: n,
     preluActivationWeights: r,
     leakyreluAlpha: a
-  }), V = R({ inputs: { x: T }, backend: o, attrs: { shape: e.outShape } });
-  B.push(T);
-  for (const O of B)
+  }), V = R({ inputs: { x: W }, backend: o, attrs: { shape: e.outShape } });
+  E.push(W);
+  for (const O of E)
     o.disposeData(O.dataId);
   return V;
 }
-function Wt({ x: i, filter: t, convInfo: e, backend: o, bias: s = null, preluActivationWeights: r = null, leakyreluAlpha: a = 0, activation: n = null }) {
+function Tt({ x: i, filter: t, convInfo: e, backend: o, bias: s = null, preluActivationWeights: r = null, leakyreluAlpha: a = 0, activation: n = null }) {
   const u = s != null, d = r != null, h = e.dataFormat === "channelsLast", l = h && e.filterHeight === e.inHeight && e.filterWidth === e.inWidth && e.padInfo.type === "VALID", c = U().getBool("WEBGPU_USE_NAIVE_CONV2D_DEBUG");
   if (!c && (l || e.filterHeight === 1 && e.filterWidth === 1 && e.dilationHeight === 1 && e.dilationWidth === 1 && e.strideHeight === 1 && e.strideWidth === 1 && (e.padInfo.type === "SAME" || e.padInfo.type === "VALID")))
     return Xd({
@@ -4708,7 +4708,7 @@ function Wt({ x: i, filter: t, convInfo: e, backend: o, bias: s = null, preluAct
  */
 function qd(i) {
   const { inputs: t, attrs: e, backend: o } = i, { x: s, filter: r } = t, { strides: a, pad: n, dataFormat: u, dilations: d, dimRoundingMode: h } = e, l = ye(u), c = ee(s.shape, r.shape, a, d, n, h, !1, l);
-  return Wt({ x: s, filter: r, convInfo: c, backend: o });
+  return Tt({ x: s, filter: r, convInfo: c, backend: o });
 }
 const Yd = {
   kernelName: Ks,
@@ -5121,10 +5121,10 @@ function sl(i = 4) {
       let xR = f32(outRow - uniforms.pads[0] + WRow) / f32(uniforms.strides[0]);
       let xC = f32(outCol - uniforms.pads[1] + WCol) / f32(uniforms.strides[1]);
       if (xR < 0.0 || xR >= f32(uniforms.outBackprop[1]) || fract(xR) > 0.0) {
-        return ${E(i)}(0.0);
+        return ${B(i)}(0.0);
       }
       if (xC < 0.0 || xC >= f32(uniforms.outBackprop[2]) || fract(xC) > 0.0) {
-        return ${E(i)}(0.0);
+        return ${B(i)}(0.0);
       }
       let coord = vec4<i32>(
           batch,
@@ -5133,13 +5133,13 @@ function sl(i = 4) {
           col % uniforms.outBackprop[3]);
       return x[getIndexFromCoords4D(coord, uniforms.xShape)/${i}];`}
       }
-      return ${E(i)}(0.0);`;
+      return ${B(i)}(0.0);`;
   return `
-  fn mm_readA(batch: i32, row : i32, col : i32) -> ${E(i)} {
+  fn mm_readA(batch: i32, row : i32, col : i32) -> ${B(i)} {
     ${o}
   }
 
-  fn mm_readB(batch: i32, row : i32, col : i32) -> ${E(i)} {
+  fn mm_readB(batch: i32, row : i32, col : i32) -> ${B(i)} {
     let coordX = uniforms.filterDims.x - 1 -
         row / (uniforms.filterDims[1] * uniforms.outBackprop[3]);
     let coordY = uniforms.filterDims.y - 1 -
@@ -5150,10 +5150,10 @@ function sl(i = 4) {
       let coord = vec4<i32>(coordX, coordY, col, rowInner);
       ${t(i)}
     }
-    return ${E(i)}(0.0);
+    return ${B(i)}(0.0);
   }
 
-  fn mm_write(batch: i32, row : i32, col : i32, valueInput : ${E(i)}) {
+  fn mm_write(batch: i32, row : i32, col : i32, valueInput : ${B(i)}) {
     if (row < uniforms.dimAOuter && col < uniforms.dimBOuter) {
       var value = valueInput;
       let outCoord = vec4<i32>(
@@ -5170,7 +5170,7 @@ class ol {
     this.variableNames = ["x", "W"], this.uniforms = "filterDims : vec2<i32>, pads : vec2<i32>, strides : vec2<i32>, outBackprop : vec4<i32>, dimAOuter : i32, dimBOuter : i32, dimInner : i32,", this.outputShape = t.inShape, L(t.dataFormat === "channelsLast", () => "TODO: NCHW is unimplemented"), this.isVec4 = t.inChannels % 4 === 0 && t.outChannels % 4 === 0, this.dispatchLayout = { x: [3], y: [1, 2], z: [0] }, this.workgroupSize = yt(this.dispatchLayout, this.outputShape, this.isVec4), this.elementsPerThread = St(this.dispatchLayout, this.outputShape, this.isVec4), this.dispatch = S(this.dispatchLayout, this.outputShape, this.workgroupSize, this.elementsPerThread), this.isVec4 && (this.outputComponent = 4, this.variableComponents = [4, 1]), this.shaderKey = `conv2DDerInputMM_${this.isVec4}_${this.elementsPerThread}`;
   }
   getUserCode() {
-    const t = this.isVec4 ? Le(this.elementsPerThread, this.workgroupSize) : Ee(this.elementsPerThread, this.workgroupSize);
+    const t = this.isVec4 ? Le(this.elementsPerThread, this.workgroupSize) : Be(this.elementsPerThread, this.workgroupSize);
     return `
     ${sl(this.isVec4 ? 4 : 1)}
     ${t}
@@ -5714,7 +5714,7 @@ function mt(i, t, e) {
  * limitations under the License.
  * =============================================================================
  */
-function Tt(i, t, e, o, s, r) {
+function Wt(i, t, e, o, s, r) {
   const a = t.shape.length, n = Se([o], a);
   let u = t;
   n != null && (u = Y({ inputs: { x: t }, backend: e, attrs: { perm: n } }));
@@ -5755,7 +5755,7 @@ function Tt(i, t, e, o, s, r) {
  */
 function bl(i) {
   const { inputs: t, backend: e, attrs: o } = i, { x: s } = t, { axis: r, exclusive: a, reverse: n } = o;
-  return Tt(we.Prod, s, e, r, a, n);
+  return Wt(we.Prod, s, e, r, a, n);
 }
 const yl = {
   kernelName: so,
@@ -5780,7 +5780,7 @@ const yl = {
  */
 function Sl(i) {
   const { inputs: t, backend: e, attrs: o } = i, { x: s } = t, { axis: r, exclusive: a, reverse: n } = o;
-  return Tt(we.Sum, s, e, r, a, n);
+  return Wt(we.Sum, s, e, r, a, n);
 }
 const vl = {
   kernelName: oo,
@@ -6349,7 +6349,7 @@ function Ll(i) {
   ];
   return e.runWebGPUProgram(c, [s, r], "float32", p);
 }
-const El = {
+const Bl = {
   kernelName: no,
   backendName: "webgpu",
   kernelFunc: Ll
@@ -6370,7 +6370,7 @@ const El = {
  * limitations under the License.
  * =============================================================================
  */
-function Bl(i) {
+function El(i) {
   const { inputs: t, backend: e, attrs: o } = i, { dy: s, filter: r } = t, { strides: a, dilations: n, pad: u, dimRoundingMode: d, inputShape: h } = o, l = ee(
     h,
     r.shape,
@@ -6396,10 +6396,10 @@ function Bl(i) {
   ];
   return e.runWebGPUProgram(c, [s, r], s.dtype, p);
 }
-const Wl = {
+const Tl = {
   kernelName: uo,
   backendName: "webgpu",
-  kernelFunc: Bl
+  kernelFunc: El
 };
 /**
  * @license
@@ -6417,7 +6417,7 @@ const Wl = {
  * limitations under the License.
  * =============================================================================
  */
-class Tl {
+class Wl {
   constructor(t) {
     this.variableNames = ["x"], this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = [t, t], this.dispatchLayout = I(this.outputShape), this.dispatch = S(this.dispatchLayout, this.outputShape, this.workgroupSize), this.shaderKey = "diag";
   }
@@ -6450,7 +6450,7 @@ class Tl {
  * =============================================================================
  */
 function _l(i) {
-  const { inputs: t, backend: e } = i, { x: o } = t, s = [...o.shape, ...o.shape], r = $(o.shape), a = R({ inputs: { x: o }, backend: e, attrs: { shape: [r] } }), n = new Tl(r), u = e.runWebGPUProgram(n, [a], a.dtype), d = R({ inputs: { x: u }, backend: e, attrs: { shape: s } });
+  const { inputs: t, backend: e } = i, { x: o } = t, s = [...o.shape, ...o.shape], r = $(o.shape), a = R({ inputs: { x: o }, backend: e, attrs: { shape: [r] } }), n = new Wl(r), u = e.runWebGPUProgram(n, [a], a.dtype), d = R({ inputs: { x: u }, backend: e, attrs: { shape: s } });
   return e.disposeData(a.dataId), e.disposeData(u.dataId), d;
 }
 const Vl = {
@@ -7387,7 +7387,7 @@ function Rc(i) {
         const M = U().getBool("CANVAS2D_WILL_READ_FREQUENTLY_FOR_GPU");
         (ne == null || M !== Ve) && (Ve = M, ne = document.createElement("canvas").getContext("2d", { willReadFrequently: Ve })), ne.canvas.width = h, ne.canvas.height = l, ne.drawImage(s, 0, 0, h, l), s = ne.canvas;
       }
-      const B = GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, G = e.textureManager.acquireTexture(c[1], c[0], "rgba8unorm", B);
+      const E = GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, G = e.textureManager.acquireTexture(c[1], c[0], "rgba8unorm", E);
       e.queue.copyExternalImageToTexture({ source: s }, { texture: G }, [c[1], c[0]]), C = G;
     }
     const w = $(c), v = Re(c), k = new Ic(c, r, p), P = [
@@ -7498,7 +7498,7 @@ const Dc = {
  */
 function Nc(i) {
   const { inputs: t, backend: e, attrs: o } = i, { x: s, filter: r, bias: a, preluActivationWeights: n } = t, { strides: u, pad: d, dataFormat: h, dilations: l, dimRoundingMode: c, activation: p, leakyreluAlpha: f } = o, m = ye(h), g = ee(s.shape, r.shape, u, l, d, c, !1, m);
-  return Wt({
+  return Tt({
     x: s,
     filter: r,
     convInfo: g,
@@ -7628,7 +7628,7 @@ function Lc(i) {
   const f = new Fc(a, [d, h]), m = [{ type: "int32", data: [a] }, { type: "int32", data: l }], g = e.runWebGPUProgram(f, [p, c], p.dtype, m), x = R({ inputs: { x: g }, backend: e, attrs: { shape: u } });
   return e.disposeData(c.dataId), e.disposeData(p.dataId), e.disposeData(g.dataId), x;
 }
-const Ec = {
+const Bc = {
   kernelName: Fo,
   backendName: "webgpu",
   kernelFunc: Lc
@@ -7649,12 +7649,12 @@ const Ec = {
  * limitations under the License.
  * =============================================================================
  */
-class Bc {
+class Ec {
   constructor(t, e) {
     this.variableNames = ["A", "indices"], this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = t.slice(), this.aShape = t, this.outputShape = e, this.dispatchLayout = I(this.outputShape), this.dispatch = S(this.dispatchLayout, this.outputShape, this.workgroupSize), this.shaderKey = "gather";
   }
   getUserCode() {
-    const t = Wc(this.aShape);
+    const t = Tc(this.aShape);
     return `
       ${y("index")} {
         if (index < uniforms.size) {
@@ -7667,7 +7667,7 @@ class Bc {
     `;
   }
 }
-function Wc(i) {
+function Tc(i) {
   const t = ["resRC.x", "resRC.y", "resRC.z", "resRC.w"], e = [];
   for (let o = 0; o < i.length; o++)
     o === 2 ? e.push("indexZ") : e.push(`${t[o]}`);
@@ -7717,12 +7717,12 @@ function Gt(i) {
     const w = e.tensorMap.get(p.dataId).values, v = de(p.shape, p.dtype, w), P = e.tensorMap.get(c.dataId).values, N = de(c.shape, c.dtype, P), A = qn(N, v, f);
     return l.forEach((z) => e.disposeData(z.dataId)), e.makeTensorInfo(d.outputShape, A.dtype, A.values);
   }
-  const m = new Bc(c.shape, f), g = e.runWebGPUProgram(m, [c, p], c.dtype);
+  const m = new Ec(c.shape, f), g = e.runWebGPUProgram(m, [c, p], c.dtype);
   l.push(g);
   const x = R({ inputs: { x: g }, backend: e, attrs: { shape: d.outputShape } });
   return l.forEach((C) => e.disposeData(C.dataId)), x;
 }
-const Tc = {
+const Wc = {
   kernelName: Lo,
   backendName: "webgpu",
   kernelFunc: Gt
@@ -7748,7 +7748,7 @@ const _c = _({
   cpuKernelImpl: Qn,
   dtype: "bool"
 }), Vc = {
-  kernelName: Eo,
+  kernelName: Bo,
   backendName: "webgpu",
   kernelFunc: _c
 };
@@ -7773,7 +7773,7 @@ const Uc = _({
   dtype: "bool",
   cpuKernelImpl: Yn
 }), Mc = {
-  kernelName: Bo,
+  kernelName: Eo,
   backendName: "webgpu",
   kernelFunc: Uc
 };
@@ -7798,7 +7798,7 @@ function Oc(i) {
   return Ot(o, !0, e);
 }
 const Gc = {
-  kernelName: Wo,
+  kernelName: To,
   backendName: "webgpu",
   kernelFunc: Oc
 };
@@ -7819,7 +7819,7 @@ const Gc = {
  * =============================================================================
  */
 const Hc = F({ opType: b.IS_FINITE, dtype: "bool" }), Xc = {
-  kernelName: To,
+  kernelName: Wo,
   backendName: "webgpu",
   kernelFunc: Hc
 };
@@ -8716,7 +8716,7 @@ const Lh = {
  * limitations under the License.
  * =============================================================================
  */
-function Eh(i) {
+function Bh(i) {
   const { inputs: t, backend: e, attrs: o } = i, { filterSize: s, strides: r, pad: a, includeBatchInIndex: n } = o, { x: u } = t;
   L(u.shape.length === 4, () => `Error in maxPool: input must be rank 4 but got rank ${u.shape.length}.`);
   const d = [1, 1];
@@ -8737,10 +8737,10 @@ function Eh(i) {
   const f = e.runWebGPUProgram(c, [u], "int32", l);
   return [p, f];
 }
-const Bh = {
+const Eh = {
   kernelName: oi,
   backendName: "webgpu",
-  kernelFunc: Eh
+  kernelFunc: Bh
 };
 /**
  * @license
@@ -8758,14 +8758,14 @@ const Bh = {
  * limitations under the License.
  * =============================================================================
  */
-function Wh(i) {
+function Th(i) {
   const { inputs: t, backend: e, attrs: o } = i, { x: s } = t, { axis: r, keepDims: a } = o;
   return re(s, r, a, "min", e);
 }
-const Th = {
+const Wh = {
   kernelName: ii,
   backendName: "webgpu",
-  kernelFunc: Wh
+  kernelFunc: Th
 };
 /**
  * @license
@@ -9245,7 +9245,7 @@ const ip = {
 function $e(i) {
   const { inputs: t, backend: e } = i, { x: o } = t;
   if (o.dtype === "complex64") {
-    const s = Ie({ inputs: { input: o }, backend: e }), r = $e({ inputs: { x: s }, backend: e }), a = We({ inputs: { input: o }, backend: e }), n = $e({ inputs: { x: a }, backend: e }), u = ie({ inputs: { real: r, imag: n }, backend: e });
+    const s = Ie({ inputs: { input: o }, backend: e }), r = $e({ inputs: { x: s }, backend: e }), a = Te({ inputs: { input: o }, backend: e }), n = $e({ inputs: { x: a }, backend: e }), u = ie({ inputs: { real: r, imag: n }, backend: e });
     return e.disposeData(s.dataId), e.disposeData(r.dataId), e.disposeData(a.dataId), e.disposeData(n.dataId), u;
   } else
     return H({
@@ -9283,7 +9283,7 @@ function Kt(i) {
   if (o.dtype === "string")
     throw new Error("onesLike is not supported under string dtype");
   if (o.dtype === "complex64") {
-    const s = Ie({ inputs: { input: o }, backend: e }), r = Kt({ inputs: { x: s }, backend: e }), a = We({ inputs: { input: o }, backend: e }), n = $e({ inputs: { x: a }, backend: e }), u = ie({ inputs: { real: r, imag: n }, backend: e });
+    const s = Ie({ inputs: { input: o }, backend: e }), r = Kt({ inputs: { x: s }, backend: e }), a = Te({ inputs: { input: o }, backend: e }), n = $e({ inputs: { x: a }, backend: e }), u = ie({ inputs: { real: r, imag: n }, backend: e });
     return e.disposeData(s.dataId), e.disposeData(r.dataId), e.disposeData(a.dataId), e.disposeData(n.dataId), u;
   } else
     return H({ attrs: { shape: o.shape, dtype: o.dtype, value: 1 }, backend: e });
@@ -9320,7 +9320,7 @@ function np(i) {
   const n = [], u = t.map((h) => {
     const l = Oe({ inputs: { input: h }, backend: e, attrs: { dim: s } });
     return n.push(l), l;
-  }), d = Bt({ inputs: u, backend: e, attrs: { axis: s } });
+  }), d = Et({ inputs: u, backend: e, attrs: { axis: s } });
   return n.forEach((h) => e.disposeData(h.dataId)), d;
 }
 const up = {
@@ -9903,17 +9903,17 @@ class Lp {
  * limitations under the License.
  * =============================================================================
  */
-function Ep(i) {
+function Bp(i) {
   const { inputs: t, backend: e, attrs: o } = i, { images: s } = t, { alignCorners: r, halfPixelCenters: a, size: n } = o, [u, d] = n, h = r && u > 1 ? 1 : 0, l = r && d > 1 ? 1 : 0, p = [
     { type: "float32", data: [h, l] },
     { type: "float32", data: [r ? 0.5 : 0] }
   ], f = new Lp(s.shape, u, d, a);
   return e.runWebGPUProgram(f, [s], s.dtype, p);
 }
-const Bp = {
+const Ep = {
   kernelName: Ni,
   backendName: "webgpu",
-  kernelFunc: Ep
+  kernelFunc: Bp
 };
 /**
  * @license
@@ -9931,7 +9931,7 @@ const Bp = {
  * limitations under the License.
  * =============================================================================
  */
-class Wp {
+class Tp {
   constructor(t, e) {
     this.variableNames = ["dy"], this.uniforms = `effectiveXSize : vec2<i32>, effectiveYSize : vec2<i32>, invHeightScale : f32, invWidthScale : f32,
        winHeight : i32, winWidth : i32,`, this.workgroupSize = [64, 1, 1], this.size = !0, this.outputShape = t, this.dispatchLayout = I(this.outputShape), this.dispatch = S(this.dispatchLayout, this.outputShape, this.workgroupSize), this.alignCorners = e, this.shaderKey = `resizeNearestNeigborBackprop_${e}`;
@@ -10015,14 +10015,14 @@ class Wp {
  * limitations under the License.
  * =============================================================================
  */
-function Tp(i) {
+function Wp(i) {
   const { inputs: t, backend: e, attrs: o } = i, { images: s, dy: r } = t, { alignCorners: a } = o, [, n, u] = s.shape, [, d, h] = r.shape, l = [
     a && d > 1 ? n - 1 : n,
     a && h > 1 ? u - 1 : u
   ], c = [
     a && d > 1 ? d - 1 : d,
     a && h > 1 ? h - 1 : h
-  ], p = l[0] / c[0], f = l[1] / c[1], m = 1 / p, g = 1 / f, x = Math.ceil(m) * 2 + 2, C = Math.ceil(g) * 2 + 2, w = new Wp(s.shape, a), v = [
+  ], p = l[0] / c[0], f = l[1] / c[1], m = 1 / p, g = 1 / f, x = Math.ceil(m) * 2 + 2, C = Math.ceil(g) * 2 + 2, w = new Tp(s.shape, a), v = [
     { type: "int32", data: l },
     { type: "int32", data: c },
     { type: "float32", data: [m] },
@@ -10035,7 +10035,7 @@ function Tp(i) {
 const _p = {
   kernelName: $i,
   backendName: "webgpu",
-  kernelFunc: Tp
+  kernelFunc: Wp
 };
 /**
  * @license
@@ -10338,7 +10338,7 @@ function Yp(i) {
   return e.disposeData(p.dataId), e.disposeData(f.dataId), e.disposeData(v.dataId), k;
 }
 const Qp = {
-  kernelName: Ei,
+  kernelName: Bi,
   backendName: "webgpu",
   kernelFunc: Yp
 };
@@ -10409,7 +10409,7 @@ function Zp(i) {
   return e.runWebGPUProgram(n, [s, r], "int32", u);
 }
 const Jp = {
-  kernelName: Bi,
+  kernelName: Ei,
   backendName: "webgpu",
   kernelFunc: Zp
 };
@@ -10481,7 +10481,7 @@ function tf(i) {
   return e.runWebGPUProgram(a, [o, s, r], ge(s.dtype, r.dtype));
 }
 const sf = {
-  kernelName: Wi,
+  kernelName: Ti,
   backendName: "webgpu",
   kernelFunc: tf
 };
@@ -10502,7 +10502,7 @@ const sf = {
  * =============================================================================
  */
 const of = F({ opType: b.SELU }), rf = {
-  kernelName: Ti,
+  kernelName: Wi,
   backendName: "webgpu",
   kernelFunc: of
 };
@@ -10942,8 +10942,8 @@ const Df = {
 function Nf(i) {
   const { inputs: t, backend: e, attrs: o } = i, { sparseIndices: s, sparseValues: r, defaultValue: a } = t, { outputShape: n } = o, { sliceRank: u, numUpdates: d, sliceSize: h, strides: l, outputSize: c } = Qe(r, s, n), p = !1;
   if (r.dtype === "string") {
-    const A = e.bufferSync(s), z = e.bufferSync(r), B = Ge(e.readSync(a.dataId)[0]), W = du(A, z, n, c, h, d, u, l, B, p);
-    return e.makeTensorInfo(n, W.dtype, W.values);
+    const A = e.bufferSync(s), z = e.bufferSync(r), E = Ge(e.readSync(a.dataId)[0]), T = du(A, z, n, c, h, d, u, l, E, p);
+    return e.makeTensorInfo(n, T.dtype, T.values);
   }
   const f = [c / h, h], m = R({
     inputs: { x: s },
@@ -11056,7 +11056,7 @@ const Ff = F({ opType: b.SQRT }), Lf = {
  * limitations under the License.
  * =============================================================================
  */
-const Ef = {
+const Bf = {
   kernelName: Zi,
   backendName: "webgpu",
   kernelFunc: ({ inputs: i, backend: t }) => {
@@ -11080,12 +11080,12 @@ const Ef = {
  * limitations under the License.
  * =============================================================================
  */
-const Bf = _({
+const Ef = _({
   opType: D.SQUARED_DIFFERENCE
-}), Wf = {
+}), Tf = {
   kernelName: Ji,
   backendName: "webgpu",
-  kernelFunc: Bf
+  kernelFunc: Ef
 };
 /**
  * @license
@@ -11103,14 +11103,14 @@ const Bf = _({
  * limitations under the License.
  * =============================================================================
  */
-function Tf({ inputs: i, attrs: t, backend: e }) {
+function Wf({ inputs: i, attrs: t, backend: e }) {
   const { x: o } = i, s = new le(o.shape, b.STEP, "stepAlpha : f32,"), r = [{ type: "float32", data: [t.alpha] }];
   return e.runWebGPUProgram(s, [o], o.dtype, r);
 }
 const _f = {
   kernelName: er,
   backendName: "webgpu",
-  kernelFunc: Tf
+  kernelFunc: Wf
 };
 /**
  * @license
@@ -11533,14 +11533,14 @@ function tm(i) {
   const h = $(n) / u, l = R({ inputs: { x: s }, attrs: { shape: [h, u] }, backend: e }), c = xt(r), p = xt(u);
   let f = null;
   const m = () => f === null ? [l, l] : [l, f], g = (k, P, N) => {
-    const A = m(), z = new Jf(N), W = [
+    const A = m(), z = new Jf(N), T = [
       { type: "int32", data: [u] },
       { type: "int32", data: [f === null ? 1 : 0] },
       { type: "float32", data: [Number.NEGATIVE_INFINITY] },
       { type: "int32", data: [k] },
       { type: "int32", data: [P] }
     ], G = f;
-    f = e.runWebGPUProgram(z, A, "int32", W), ue(e, G);
+    f = e.runWebGPUProgram(z, A, "int32", T), ue(e, G);
   };
   for (let k = 1; k < c; k *= 2) {
     const P = k * 2;
@@ -11552,10 +11552,10 @@ function tm(i) {
       { type: "int32", data: [u] },
       { type: "int32", data: [f === null ? 1 : 0] },
       { type: "int32", data: [c] }
-    ], B = f;
-    f = e.runWebGPUProgram(N, P, "int32", z), ue(e, B);
-    const W = c / 2, G = W * 2;
-    for (let M = W; M >= 1; M /= 2)
+    ], E = f;
+    f = e.runWebGPUProgram(N, P, "int32", z), ue(e, E);
+    const T = c / 2, G = T * 2;
+    for (let M = T; M >= 1; M /= 2)
       g(G, M, f.shape);
   }
   let x = f;
@@ -11869,7 +11869,7 @@ function dm(i) {
   const h = Se([d], n);
   let l = s;
   h != null && (l = Y({ inputs: { x: s }, backend: e, attrs: { perm: h } }), u.push(l), d = ve(1, n)[0]);
-  const c = Er(l.shape, d, a), p = $([l.shape[d]]), f = R({ inputs: { x: l }, backend: e, attrs: { shape: [-1, p] } });
+  const c = Br(l.shape, d, a), p = $([l.shape[d]]), f = R({ inputs: { x: l }, backend: e, attrs: { shape: [-1, p] } });
   u.push(f);
   const m = s.dtype, g = [f.shape[0], a], x = H({ backend: e, attrs: { shape: g, value: 0, dtype: m } }), C = new um(f.shape, g, m), w = [
     { type: "int32", data: [a] },
@@ -11906,14 +11906,14 @@ const lm = {
  * =============================================================================
  */
 const cm = [
-  En,
+  Bn,
   wu,
   yu,
   vu,
   ku,
   Du,
-  Eu,
-  Wu,
+  Bu,
+  Tu,
   _u,
   Uu,
   Ou,
@@ -11932,8 +11932,8 @@ const cm = [
   Dd,
   $d,
   Ld,
-  Wn,
-  Wd,
+  Tn,
+  Td,
   Ud,
   Yd,
   tl,
@@ -11948,8 +11948,8 @@ const cm = [
   vl,
   kl,
   Dl,
-  El,
-  Wl,
+  Bl,
+  Tl,
   zl,
   Vl,
   Ol,
@@ -11973,11 +11973,11 @@ const cm = [
   Dc,
   $c,
   Ac,
-  Ec,
-  Tc,
+  Bc,
+  Wc,
   Vc,
   Mc,
-  Bn,
+  En,
   Gc,
   _d,
   Xc,
@@ -12000,9 +12000,9 @@ const cm = [
   Lh,
   Dh,
   Ah,
-  Bh,
+  Eh,
   ed,
-  Th,
+  Wh,
   Vh,
   Mh,
   Gh,
@@ -12028,7 +12028,7 @@ const cm = [
   Mr,
   $p,
   Fp,
-  Bp,
+  Ep,
   _p,
   Mp,
   Gp,
@@ -12054,8 +12054,8 @@ const cm = [
   $f,
   Af,
   Lf,
-  Ef,
-  Wf,
+  Bf,
+  Tf,
   Xf,
   ec,
   qf,