@genai-fi/nanogpt 0.6.2 → 0.7.0

package/dist/gpgpu_math-DJm3ZTAf.js

@@ -0,0 +1,2371 @@
+import { ay as z, ac as v, az as oe, aA as ie, aB as ae, l as F, aC as me, aD as J, Z as B, aE as I, ab as T, j as E, aF as H, aG as $e, aH as Y, aa as Te } from "./index-C0dhsYom.js";
+import "./index-Tf7vU29b.js";
+import { b as Se } from "./backend_util-DWiwsi2N.js";
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const Re = "model", Ee = ".json", Ce = ".weights.bin";
+function K(e) {
+  return new Promise((t) => setTimeout(t)).then(e);
+}
+class N {
+  constructor(t) {
+    if (!v().getBool("IS_BROWSER"))
+      throw new Error("browserDownloads() cannot proceed because the current environment is not a browser.");
+    t.startsWith(N.URL_SCHEME) && (t = t.slice(N.URL_SCHEME.length)), (t == null || t.length === 0) && (t = Re), this.modelJsonFileName = t + Ee, this.weightDataFileName = t + Ce;
+  }
+  async save(t) {
+    if (typeof document > "u")
+      throw new Error("Browser downloads are not supported in this environment since `document` is not present");
+    const n = oe.join(t.weightData), r = window.URL.createObjectURL(new Blob([n], { type: "application/octet-stream" }));
+    if (t.modelTopology instanceof ArrayBuffer)
+      throw new Error("BrowserDownloads.save() does not support saving model topology in binary formats yet.");
+    {
+      const o = [{
+        paths: ["./" + this.weightDataFileName],
+        weights: t.weightSpecs
+      }], i = ie(t, o), a = window.URL.createObjectURL(new Blob([JSON.stringify(i)], { type: "application/json" })), s = this.modelJsonAnchor == null ? document.createElement("a") : this.modelJsonAnchor;
+      if (s.download = this.modelJsonFileName, s.href = a, await K(() => s.dispatchEvent(new MouseEvent("click"))), t.weightData != null) {
+        const c = this.weightDataAnchor == null ? document.createElement("a") : this.weightDataAnchor;
+        c.download = this.weightDataFileName, c.href = r, await K(() => c.dispatchEvent(new MouseEvent("click")));
+      }
+      return { modelArtifactsInfo: ae(t) };
+    }
+  }
+}
+N.URL_SCHEME = "downloads://";
+const we = (e) => v().getBool("IS_BROWSER") && !Array.isArray(e) && e.startsWith(N.URL_SCHEME) ? Fe(e.slice(N.URL_SCHEME.length)) : null;
+z.registerSaveRouter(we);
+function Fe(e = "model") {
+  return new N(e);
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Z(e, t, n, r) {
+  a(e), n = n ?? 0, r = r ?? 1, s(n, r);
+  let o = 0;
+  const i = (c) => (c.then((u) => {
+    const l = n + ++o / e.length * (r - n);
+    return t(l), u;
+  }), c);
+  function a(c) {
+    F(c != null && Array.isArray(c) && c.length > 0, () => "promises must be a none empty array");
+  }
+  function s(c, u) {
+    F(c >= 0 && c <= 1, () => `Progress fraction must be in range [0, 1], but got startFraction ${c}`), F(u >= 0 && u <= 1, () => `Progress fraction must be in range [0, 1], but got endFraction ${u}`), F(u >= c, () => `startFraction must be no more than endFraction, but got startFraction ${c} and endFraction ${u}`);
+  }
+  return Promise.all(e.map(i));
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+async function ge(e, t) {
+  t == null && (t = {});
+  const n = t.fetchFunc == null ? v().platform.fetch : t.fetchFunc, r = e.map((f) => n(f, t.requestInit, { isBinary: !0 })), s = (t.onProgress == null ? await Promise.all(r) : await Z(r, t.onProgress, 0, 0.5)).map((f) => f.arrayBuffer());
+  return t.onProgress == null ? await Promise.all(s) : await Z(s, t.onProgress, 0.5, 1);
+}
+function Ae(e, t) {
+  var n;
+  const r = t.fetchFunc == null ? v().platform.fetch : t.fetchFunc;
+  let o = 0, i;
+  return (n = t.onProgress) === null || n === void 0 || n.call(t, 0), new ReadableStream({
+    pull: async (a) => {
+      for (var s; o < e.length; ) {
+        i || (i = (await r(e[o], t.requestInit, { isBinary: !0 })).body.getReader());
+        const { done: c, value: u } = await i.read();
+        if (c) {
+          o++, i = void 0, (s = t.onProgress) === null || s === void 0 || s.call(t, o / e.length);
+          continue;
+        }
+        a.enqueue(u);
+        return;
+      }
+      a.close();
+    }
+  });
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const _e = "application/octet-stream", Ne = "application/json";
+class q {
+  constructor(t, n) {
+    if (this.DEFAULT_METHOD = "POST", n == null && (n = {}), this.weightPathPrefix = n.weightPathPrefix, this.weightUrlConverter = n.weightUrlConverter, n.fetchFunc != null ? (F(typeof n.fetchFunc == "function", () => "Must pass a function that matches the signature of `fetch` (see https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)"), this.fetch = n.fetchFunc) : this.fetch = v().platform.fetch, F(t != null && t.length > 0, () => "URL path for http must not be null, undefined or empty."), Array.isArray(t) && F(t.length === 2, () => `URL paths for http must have a length of 2, (actual length is ${t.length}).`), this.path = t, n.requestInit != null && n.requestInit.body != null)
+      throw new Error("requestInit is expected to have no pre-existing body, but has one.");
+    this.requestInit = n.requestInit || {}, this.loadOptions = n;
+  }
+  async save(t) {
+    if (t.modelTopology instanceof ArrayBuffer)
+      throw new Error("BrowserHTTPRequest.save() does not support saving model topology in binary formats yet.");
+    const n = Object.assign({ method: this.DEFAULT_METHOD }, this.requestInit);
+    n.body = new FormData();
+    const r = [{
+      paths: ["./model.weights.bin"],
+      weights: t.weightSpecs
+    }], o = ie(t, r);
+    if (n.body.append("model.json", new Blob([JSON.stringify(o)], { type: Ne }), "model.json"), t.weightData != null) {
+      const a = oe.join(t.weightData);
+      n.body.append("model.weights.bin", new Blob([a], { type: _e }), "model.weights.bin");
+    }
+    const i = await this.fetch(this.path, n);
+    if (i.ok)
+      return {
+        modelArtifactsInfo: ae(t),
+        responses: [i]
+      };
+    throw new Error(`BrowserHTTPRequest.save() failed due to HTTP response status ${i.status}.`);
+  }
+  async loadModelJSON() {
+    const t = await this.fetch(this.path, this.requestInit);
+    if (!t.ok)
+      throw new Error(`Request to ${this.path} failed with status code ${t.status}. Please verify this URL points to the model JSON of the model to load.`);
+    let n;
+    try {
+      n = await t.json();
+    } catch {
+      let a = `Failed to parse model JSON of response from ${this.path}.`;
+      throw this.path.endsWith(".pb") ? a += " Your path contains a .pb file extension. Support for .pb models have been removed in TensorFlow.js 1.0 in favor of .json models. You can re-convert your Python TensorFlow model using the TensorFlow.js 1.0 conversion scripts or you can convert your.pb models with the 'pb2json'NPM script in the tensorflow/tfjs-converter repository." : a += " Please make sure the server is serving valid JSON for this request.", new Error(a);
+    }
+    const r = n.modelTopology, o = n.weightsManifest;
+    if (r == null && o == null)
+      throw new Error(`The JSON from HTTP path ${this.path} contains neither model topology or manifest for weights.`);
+    return n;
+  }
+  /**
+   * Load model artifacts via HTTP request(s).
+   *
+   * See the documentation to `tf.io.http` for details on the saved
+   * artifacts.
+   *
+   * @returns The loaded model artifacts (if loading succeeds).
+   */
+  async load() {
+    if (this.loadOptions.streamWeights)
+      return this.loadStream();
+    const t = await this.loadModelJSON();
+    return me(t, (n) => this.loadWeights(n));
+  }
+  async loadStream() {
+    const t = await this.loadModelJSON(), n = await this.getWeightUrls(t.weightsManifest), r = J(t.weightsManifest), o = () => Ae(n, this.loadOptions);
+    return Object.assign(Object.assign({}, t), { weightSpecs: r, getWeightStream: o });
+  }
+  async getWeightUrls(t) {
+    const n = Array.isArray(this.path) ? this.path[1] : this.path, [r, o] = Ie(n), i = this.weightPathPrefix || r, a = [], s = [];
+    for (const c of t)
+      for (const u of c.paths)
+        this.weightUrlConverter != null ? s.push(this.weightUrlConverter(u)) : a.push(i + u + o);
+    return this.weightUrlConverter && a.push(...await Promise.all(s)), a;
+  }
+  async loadWeights(t) {
+    const n = await this.getWeightUrls(t), r = J(t), o = await ge(n, this.loadOptions);
+    return [r, o];
+  }
+}
+q.URL_SCHEME_REGEX = /^https?:\/\//;
+function Ie(e) {
+  const t = e.lastIndexOf("/"), n = e.lastIndexOf("?"), r = e.substring(0, t), o = n > t ? e.substring(n) : "";
+  return [r + "/", o];
+}
+function Q(e) {
+  return e.match(q.URL_SCHEME_REGEX) != null;
+}
+const ce = (e, t) => {
+  if (typeof fetch > "u" && (t == null || t.fetchFunc == null))
+    return null;
+  {
+    let n = !0;
+    if (Array.isArray(e) ? n = e.every((r) => Q(r)) : n = Q(e), n)
+      return Ue(e, t);
+  }
+  return null;
+};
+z.registerSaveRouter(ce);
+z.registerLoadRouter(ce);
+function Ue(e, t) {
+  return new q(e, t);
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function L() {
+  let e, t, n, r, o, i, a, s, c, u;
+  return v().getNumber("WEBGL_VERSION") === 2 ? (e = "#version 300 es", t = "in", n = "out", r = "in", o = "texture", i = "outputColor", a = "out vec4 outputColor;", s = v().getBool("WEBGL2_ISNAN_CUSTOM") ? `
+      bool isnan_custom(float val) {
+        uint floatToUint = floatBitsToUint(val);
+        return (floatToUint & 0x7fffffffu) > 0x7f800000u;
+      }
+
+      bvec4 isnan_custom(vec4 val) {
+        return bvec4(isnan_custom(val.x),
+          isnan_custom(val.y), isnan_custom(val.z), isnan_custom(val.w));
+      }
+
+      #define isnan(value) isnan_custom(value)
+    ` : "", c = "", u = `
+      #define round(value) newRound(value)
+      int newRound(float value) {
+        return int(floor(value + 0.5));
+      }
+
+      ivec4 newRound(vec4 value) {
+        return ivec4(floor(value + vec4(0.5)));
+      }
+    `) : (e = "", t = "attribute", n = "varying", r = "varying", o = "texture2D", i = "gl_FragColor", a = "", s = `
+      #define isnan(value) isnan_custom(value)
+      bool isnan_custom(float val) {
+        return (val > 0. || val < 1. || val == 0.) ? false : true;
+      }
+      bvec4 isnan_custom(vec4 val) {
+        return bvec4(isnan(val.x), isnan(val.y), isnan(val.z), isnan(val.w));
+      }
+    `, c = `
+      uniform float INFINITY;
+
+      bool isinf(float val) {
+        return abs(val) == INFINITY;
+      }
+      bvec4 isinf(vec4 val) {
+        return equal(abs(val), vec4(INFINITY));
+      }
+    `, u = `
+      int round(float value) {
+        return int(floor(value + 0.5));
+      }
+
+      ivec4 round(vec4 value) {
+        return ivec4(floor(value + vec4(0.5)));
+      }
+    `), {
+    version: e,
+    attribute: t,
+    varyingVs: n,
+    varyingFs: r,
+    texture2D: o,
+    output: i,
+    defineOutput: a,
+    defineSpecialNaN: s,
+    defineSpecialInf: c,
+    defineRound: u
+  };
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function V(e, t, n = "index") {
+  const r = B(t);
+  return r.map((o, i) => {
+    const a = `int ${e[i]} = ${n} / ${o}`, s = i === r.length - 1 ? `int ${e[i + 1]} = ${n} - ${e[i]} * ${o}` : `index -= ${e[i]} * ${o}`;
+    return `${a}; ${s};`;
+  }).join("");
+}
+function se(e, t, n = "index") {
+  const r = B(t);
+  return r.map((o, i) => {
+    const a = `int ${e[i]} = ${n} / outShapeStrides[${i}]`, s = i === r.length - 1 ? `int ${e[i + 1]} = ${n} - ${e[i]} * outShapeStrides[${i}]` : `index -= ${e[i]} * outShapeStrides[${i}]`;
+    return `${a}; ${s};`;
+  }).join("");
+}
+function Oe(e, t) {
+  const n = e.length, r = e.map((i) => `${t}[${i}]`), o = new Array(n - 1);
+  o[n - 2] = r[n - 1];
+  for (let i = n - 3; i >= 0; --i)
+    o[i] = `(${o[i + 1]} * ${r[i + 1]})`;
+  return o;
+}
+function Lt(e, t, n = "index") {
+  const r = e.map((i, a) => a), o = Oe(r, t);
+  return o.map((i, a) => {
+    const s = `int ${e[a]} = ${n} / ${o[a]}`, c = a === o.length - 1 ? `int ${e[a + 1]} = ${n} - ${e[a]} * ${o[a]}` : `index -= ${e[a]} * ${o[a]}`;
+    return `${s}; ${c};`;
+  }).join("");
+}
+function bt(e) {
+  const t = B(e).map((n) => n.toString());
+  return `
+  int getFlatIndex(ivec3 coords) {
+    return coords.x * ${t[0]} + coords.y * ${t[1]} + coords.z;
+  }
+`;
+}
+function Dt() {
+  return `
+  int getFlatIndex(ivec3 coords) {
+    return coords.x * outShapeStrides[0] + coords.y * outShapeStrides[1] + coords.z;
+  }
+`;
+}
+const yt = `
+  const float FLOAT_MAX = 1.70141184e38;
+  const float FLOAT_MIN = 1.17549435e-38;
+
+  lowp vec4 encode_float(highp float v) {
+    if (isnan(v)) {
+      return vec4(255, 255, 255, 255);
+    }
+
+    highp float av = abs(v);
+
+    if(av < FLOAT_MIN) {
+      return vec4(0.0, 0.0, 0.0, 0.0);
+    } else if(v > FLOAT_MAX) {
+      return vec4(0.0, 0.0, 128.0, 127.0) / 255.0;
+    } else if(v < -FLOAT_MAX) {
+      return vec4(0.0, 0.0,  128.0, 255.0) / 255.0;
+    }
+
+    highp vec4 c = vec4(0,0,0,0);
+
+    highp float e = floor(log2(av));
+    highp float m = exp2(fract(log2(av))) - 1.0;
+
+    c[2] = floor(128.0 * m);
+    m -= c[2] / 128.0;
+    c[1] = floor(32768.0 * m);
+    m -= c[1] / 32768.0;
+    c[0] = floor(8388608.0 * m);
+
+    highp float ebias = e + 127.0;
+    c[3] = floor(ebias / 2.0);
+    ebias -= c[3] * 2.0;
+    c[2] += floor(ebias) * 128.0;
+
+    c[3] += 128.0 * step(0.0, -v);
+
+    return c / 255.0;
+  }
+`;
+/**
+ * @license
+ * Copyright 2017 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const { getBroadcastDims: ue } = Se;
+function Le(e, t, n) {
+  const r = [];
+  if (e.forEach((h) => {
+    const x = E(h.shapeInfo.logicalShape);
+    if (h.shapeInfo.isUniform ? r.push(`uniform float ${h.name}${x > 1 ? `[${x}]` : ""};`) : (r.push(`uniform sampler2D ${h.name};`), r.push(`uniform int offset${h.name};`)), n.enableShapeUniforms) {
+      const { uniformShape: p } = j(n.packedInputs, h.shapeInfo.logicalShape, h.shapeInfo.texShape);
+      switch (p.length) {
+        case 1:
+          r.push(`uniform int ${h.name}Shape;`);
+          break;
+        case 2:
+          r.push(`uniform ivec2 ${h.name}Shape;`);
+          break;
+        case 3:
+          r.push(`uniform ivec3 ${h.name}Shape;`);
+          break;
+        case 4:
+          r.push(`uniform ivec4 ${h.name}Shape;`);
+          break;
+      }
+      r.push(`uniform ivec2 ${h.name}TexShape;`);
+    }
+  }), n.enableShapeUniforms) {
+    switch (t.logicalShape.length) {
+      case 1:
+        r.push("uniform int outShape;");
+        break;
+      case 2:
+        r.push("uniform ivec2 outShape;"), r.push("uniform int outShapeStrides;");
+        break;
+      case 3:
+        r.push("uniform ivec3 outShape;"), r.push("uniform ivec2 outShapeStrides;");
+        break;
+      case 4:
+        r.push("uniform ivec4 outShape;"), r.push("uniform ivec3 outShapeStrides;");
+        break;
+    }
+    r.push("uniform ivec2 outTexShape;");
+  }
+  n.customUniforms && n.customUniforms.forEach((h) => {
+    r.push(`uniform ${h.type} ${h.name}${h.arrayIndex ? `[${h.arrayIndex}]` : ""};`);
+  });
+  const o = r.join(`
+`), i = e.map((h) => be(h, t, n.packedInputs, n.enableShapeUniforms)).join(`
+`), a = t.texShape, s = L(), c = Me(s);
+  let u, l, f = Pe(s);
+  return t.isPacked ? (u = De(t.logicalShape, a, n.enableShapeUniforms), l = ke(s)) : (u = ye(t.logicalShape, a, n.enableShapeUniforms), l = Be(s)), n.packedInputs && (f += He), [
+    f,
+    c,
+    l,
+    o,
+    u,
+    i,
+    n.userCode
+  ].join(`
+`);
+}
+function b(e, t = !1) {
+  const n = e.shapeInfo.logicalShape;
+  switch (n.length) {
+    case 0:
+      return nt(e, t);
+    case 1:
+      return ot(e, t);
+    case 2:
+      return at(e, t);
+    case 3:
+      return st(e, t);
+    case 4:
+      return lt(e, t);
+    case 5:
+      return ft(e);
+    case 6:
+      return ht(e);
+    default:
+      throw new Error(`${n.length}-D input sampling is not yet supported`);
+  }
+}
+function le(e, t) {
+  switch (e.shapeInfo.logicalShape.length) {
+    case 0:
+      return tt(e);
+    case 1:
+      return rt(e, t);
+    case 2:
+      return it(e, t);
+    case 3:
+      return ct(e, t);
+    default:
+      return ut(e, t);
+  }
+}
+function be(e, t, n = !1, r) {
+  let o = "";
+  n ? o += le(e, r) : o += b(e, r);
+  const i = e.shapeInfo.logicalShape, a = t.logicalShape;
+  return i.length <= a.length && (n ? o += dt(e, t) : o += xt(e, t)), o;
+}
+function De(e, t, n) {
+  switch (e.length) {
+    case 0:
+      return fe();
+    case 1:
+      return Ge(e, t, n);
+    case 2:
+      return Qe(e, t, n);
+    case 3:
+      return qe(e, t, n);
+    default:
+      return Je(e, t, n);
+  }
+}
+function ye(e, t, n) {
+  switch (e.length) {
+    case 0:
+      return fe();
+    case 1:
+      return ze(e, t, n);
+    case 2:
+      return et(e, t, n);
+    case 3:
+      return je(e, t, n);
+    case 4:
+      return Ye(e, t, n);
+    case 5:
+      return Ke(e, t);
+    case 6:
+      return Ze(e, t);
+    default:
+      throw new Error(`${e.length}-D output sampling is not yet supported`);
+  }
+}
+function Me(e) {
+  return `
+    float sampleTexture(sampler2D textureSampler, vec2 uv) {
+      return ${e.texture2D}(textureSampler, uv).r;
+    }
+  `;
+}
+function Be(e) {
+  return `
+    void setOutput(float val) {
+      ${e.output} = vec4(val, 0, 0, 0);
+    }
+  `;
+}
+function ke(e) {
+  return `
+    void setOutput(vec4 val) {
+      ${e.output} = val;
+    }
+  `;
+}
+function Pe(e) {
+  return `${e.version}
+    precision highp float;
+    precision highp int;
+    precision highp sampler2D;
+    ${e.varyingFs} vec2 resultUV;
+    ${e.defineOutput}
+    const vec2 halfCR = vec2(0.5, 0.5);
+
+    struct ivec5
+    {
+      int x;
+      int y;
+      int z;
+      int w;
+      int u;
+    };
+
+    struct ivec6
+    {
+      int x;
+      int y;
+      int z;
+      int w;
+      int u;
+      int v;
+    };
+
+    uniform float NAN;
+    ${e.defineSpecialNaN}
+    ${e.defineSpecialInf}
+    ${e.defineRound}
+
+    int imod(int x, int y) {
+      return x - y * (x / y);
+    }
+
+    int idiv(int a, int b, float sign) {
+      int res = a / b;
+      int mod = imod(a, b);
+      if (sign < 0. && mod != 0) {
+        res -= 1;
+      }
+      return res;
+    }
+
+    //Based on the work of Dave Hoskins
+    //https://www.shadertoy.com/view/4djSRW
+    #define HASHSCALE1 443.8975
+    float random(float seed){
+      vec2 p = resultUV * seed;
+      vec3 p3  = fract(vec3(p.xyx) * HASHSCALE1);
+      p3 += dot(p3, p3.yzx + 19.19);
+      return fract((p3.x + p3.y) * p3.z);
+    }
+
+    ${Ve}
+    ${We}
+    ${Xe}
+  `;
+}
+const Ve = `
+vec2 uvFromFlat(int texNumR, int texNumC, int index) {
+  int texR = index / texNumC;
+  int texC = index - texR * texNumC;
+  return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);
+}
+vec2 packedUVfrom1D(int texNumR, int texNumC, int index) {
+  int texelIndex = index / 2;
+  int texR = texelIndex / texNumC;
+  int texC = texelIndex - texR * texNumC;
+  return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);
+}
+`, We = `
+vec2 packedUVfrom2D(int texelsInLogicalRow, int texNumR,
+  int texNumC, int row, int col) {
+  int texelIndex = (row / 2) * texelsInLogicalRow + (col / 2);
+  int texR = texelIndex / texNumC;
+  int texC = texelIndex - texR * texNumC;
+  return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);
+}
+`, Xe = `
+vec2 packedUVfrom3D(int texNumR, int texNumC,
+    int texelsInBatch, int texelsInLogicalRow, int b,
+    int row, int col) {
+  int index = b * texelsInBatch + (row / 2) * texelsInLogicalRow + (col / 2);
+  int texR = index / texNumC;
+  int texC = index - texR * texNumC;
+  return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);
+}
+`, He = `
+  float getChannel(vec4 frag, vec2 innerDims) {
+    vec2 modCoord = mod(innerDims, 2.);
+    return modCoord.x == 0. ?
+      (modCoord.y == 0. ? frag.r : frag.g) :
+      (modCoord.y == 0. ? frag.b : frag.a);
+  }
+  float getChannel(vec4 frag, int dim) {
+    float modCoord = mod(float(dim), 2.);
+    return modCoord == 0. ? frag.r : frag.g;
+  }
+`;
+function fe() {
+  return `
+    int getOutputCoords() {
+      return 0;
+    }
+  `;
+}
+function Ge(e, t, n) {
+  const r = [Math.ceil(t[0] / 2), Math.ceil(t[1] / 2)];
+  return r[0] === 1 ? n ? `
+      int getOutputCoords() {
+        return 2 * int(resultUV.x * ceil(float(outTexShape[1]) / 2.0));
+      }
+    ` : `
+      int getOutputCoords() {
+        return 2 * int(resultUV.x * ${r[1]}.0);
+      }
+    ` : r[1] === 1 ? n ? `
+      int getOutputCoords() {
+        return 2 * int(resultUV.y * ceil(float(outTexShape[0]) / 2.0));
+      }
+    ` : `
+      int getOutputCoords() {
+        return 2 * int(resultUV.y * ${r[0]}.0);
+      }
+    ` : n ? `
+    int getOutputCoords() {
+      ivec2 packedTexShape = ivec2(ceil(float(outTexShape[0]) / 2.0), ceil(float(outTexShape[1]) / 2.0));
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(packedTexShape[0], packedTexShape[1]));
+      return 2 * (resTexRC.x * packedTexShape[1] + resTexRC.y);
+    }
+  ` : `
+    int getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${r[0]}, ${r[1]}));
+      return 2 * (resTexRC.x * ${r[1]} + resTexRC.y);
+    }
+  `;
+}
+function ze(e, t, n) {
+  return t[0] === 1 ? n ? `
+      int getOutputCoords() {
+        return int(resultUV.x * float(outTexShape[1]));
+      }
+    ` : `
+      int getOutputCoords() {
+        return int(resultUV.x * ${t[1]}.0);
+      }
+    ` : t[1] === 1 ? n ? `
+      int getOutputCoords() {
+        return int(resultUV.y * float(outTexShape[0]));
+      }
+    ` : `
+      int getOutputCoords() {
+        return int(resultUV.y * ${t[0]}.0);
+      }
+    ` : n ? `
+    int getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(outTexShape[0], outTexShape[1]));
+      return resTexRC.x * outTexShape[1] + resTexRC.y;
+    }
+  ` : `
+    int getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${t[0]}, ${t[1]}));
+      return resTexRC.x * ${t[1]} + resTexRC.y;
+    }
+  `;
+}
+function qe(e, t, n) {
+  if (n)
+    return `
+    ivec3 getOutputCoords() {
+      ivec2 packedTexShape = ivec2(ceil(float(outTexShape[0]) / 2.0), ceil(float(outTexShape[1]) / 2.0));
+      int texelsInLogicalRow = int(ceil(float(outShape[2]) / 2.0));
+      int texelsInBatch = texelsInLogicalRow * int(ceil(float(outShape[1]) / 2.0));
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(packedTexShape[0], packedTexShape[1]));
+      int index = resTexRC.x * packedTexShape[1] + resTexRC.y;
+
+      int b = index / texelsInBatch;
+      index -= b * texelsInBatch;
+
+      int r = 2 * (index / texelsInLogicalRow);
+      int c = imod(index, texelsInLogicalRow) * 2;
+
+      return ivec3(b, r, c);
+    }
+  `;
+  const r = [Math.ceil(t[0] / 2), Math.ceil(t[1] / 2)], o = Math.ceil(e[2] / 2), i = o * Math.ceil(e[1] / 2);
+  return `
+    ivec3 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${r[0]}, ${r[1]}));
+      int index = resTexRC.x * ${r[1]} + resTexRC.y;
+
+      int b = index / ${i};
+      index -= b * ${i};
+
+      int r = 2 * (index / ${o});
+      int c = imod(index, ${o}) * 2;
+
+      return ivec3(b, r, c);
+    }
+  `;
+}
+function je(e, t, n) {
+  if (n)
+    return `
+  ivec3 getOutputCoords() {
+    ivec2 resTexRC = ivec2(resultUV.yx *
+                           vec2(outTexShape[0], outTexShape[1]));
+    int index = resTexRC.x * outTexShape[1] + resTexRC.y;
+    ${se(["r", "c", "d"], e)}
+    return ivec3(r, c, d);
+  }
+`;
+  const r = V(["r", "c", "d"], e);
+  return `
+    ivec3 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${t[0]}, ${t[1]}));
+      int index = resTexRC.x * ${t[1]} + resTexRC.y;
+      ${r}
+      return ivec3(r, c, d);
+    }
+  `;
+}
+function Je(e, t, n) {
+  if (n)
+    return `
+    ivec4 getOutputCoords() {
+      ivec2 packedTexShape = ivec2(ceil(float(outTexShape[0]) / 2.0), ceil(float(outTexShape[1]) / 2.0));
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(packedTexShape[0], packedTexShape[1]));
+      int index = resTexRC.x * packedTexShape[1] + resTexRC.y;
+
+      int texelsInLogicalRow = int(ceil(float(outShape[3]) / 2.0));
+      int texelsInBatch = texelsInLogicalRow * int(ceil(float(outShape[2]) / 2.0));
+      int texelsInBatchN = texelsInBatch * outShape[1];
+
+      int b2 = index / texelsInBatchN;
+      index -= b2 * texelsInBatchN;
+
+      int b = index / texelsInBatch;
+      index -= b * texelsInBatch;
+
+      int r = 2 * (index / texelsInLogicalRow);
+      int c = imod(index, texelsInLogicalRow) * 2;
+
+      return ivec4(b2, b, r, c);
+    }
+  `;
+  const r = [Math.ceil(t[0] / 2), Math.ceil(t[1] / 2)], o = Math.ceil(e[e.length - 1] / 2), i = o * Math.ceil(e[e.length - 2] / 2);
+  let a = i, s = "", c = "b, r, c";
+  for (let u = 2; u < e.length - 1; u++)
+    a *= e[e.length - u - 1], s = `
+      int b${u} = index / ${a};
+      index -= b${u} * ${a};
+    ` + s, c = `b${u}, ` + c;
+  return `
+    ivec${e.length} getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${r[0]}, ${r[1]}));
+      int index = resTexRC.x * ${r[1]} + resTexRC.y;
+
+      ${s}
+
+      int b = index / ${i};
+      index -= b * ${i};
+
+      int r = 2 * (index / ${o});
+      int c = imod(index, ${o}) * 2;
+
+      return ivec${e.length}(${c});
+    }
+  `;
+}
+function Ye(e, t, n) {
+  if (n)
+    return `
+    ivec4 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+        vec2(outTexShape[0], outTexShape[1]));
+      int index = resTexRC.x * outTexShape[1] + resTexRC.y;
+      ${se(["r", "c", "d", "d2"], e)}
+      return ivec4(r, c, d, d2);
+    }
+  `;
+  const r = V(["r", "c", "d", "d2"], e);
+  return `
+    ivec4 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+        vec2(${t[0]}, ${t[1]}));
+      int index = resTexRC.x * ${t[1]} + resTexRC.y;
+      ${r}
+      return ivec4(r, c, d, d2);
+    }
+  `;
+}
+function Ke(e, t) {
+  const n = V(["r", "c", "d", "d2", "d3"], e);
+  return `
+    ivec5 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx * vec2(${t[0]},
+                             ${t[1]}));
+
+      int index = resTexRC.x * ${t[1]} + resTexRC.y;
+
+      ${n}
+
+      ivec5 outShape = ivec5(r, c, d, d2, d3);
+      return outShape;
+    }
+  `;
+}
+function Ze(e, t) {
+  const n = V(["r", "c", "d", "d2", "d3", "d4"], e);
+  return `
+    ivec6 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+        vec2(${t[0]}, ${t[1]}));
+      int index = resTexRC.x * ${t[1]} + resTexRC.y;
+
+      ${n}
+
+      ivec6 result = ivec6(r, c, d, d2, d3, d4);
+      return result;
+    }
+  `;
+}
+function Qe(e, t, n) {
+  const r = [Math.ceil(t[0] / 2), Math.ceil(t[1] / 2)];
+  if (T(e, t))
+    return n ? `
+      ivec2 getOutputCoords() {
+        ivec2 packedTexShape = ivec2(ceil(float(outTexShape[0]) / 2.0), ceil(float(outTexShape[1]) / 2.0));
+        return 2 * ivec2(resultUV.yx * vec2(packedTexShape[0], packedTexShape[1]));
+      }
+    ` : `
+      ivec2 getOutputCoords() {
+        return 2 * ivec2(resultUV.yx * vec2(${r[0]}, ${r[1]}));
+      }
+    `;
+  const o = Math.ceil(e[1] / 2);
+  return n ? `
+    ivec2 getOutputCoords() {
+      ivec2 packedTexShape = ivec2(ceil(float(outTexShape[0]) / 2.0), ceil(float(outTexShape[1]) / 2.0));
+      int texelsInLogicalRow = int(ceil(float(outShape[1]) / 2.0));
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(packedTexShape[0], packedTexShape[1]));
+
+      int index = resTexRC.x * packedTexShape[1] + resTexRC.y;
+      int r = 2 * (index / texelsInLogicalRow);
+      int c = imod(index, texelsInLogicalRow) * 2;
+
+      return ivec2(r, c);
+    }
+  ` : `
+    ivec2 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${r[0]}, ${r[1]}));
+
+      int index = resTexRC.x * ${r[1]} + resTexRC.y;
+      int r = 2 * (index / ${o});
+      int c = imod(index, ${o}) * 2;
+
+      return ivec2(r, c);
+    }
+  `;
+}
+function et(e, t, n) {
+  return T(e, t) ? n ? `
+      ivec2 getOutputCoords() {
+        return ivec2(resultUV.yx * vec2(outTexShape[0], outTexShape[1]));
+      }
+    ` : `
+      ivec2 getOutputCoords() {
+        return ivec2(resultUV.yx * vec2(${t[0]}, ${t[1]}));
+      }
+    ` : e[1] === 1 ? n ? `
+      ivec2 getOutputCoords() {
+        ivec2 resTexRC = ivec2(resultUV.yx *
+                               vec2(outTexShape[0], outTexShape[1]));
+        int index = resTexRC.x * outTexShape[1] + resTexRC.y;
+        return ivec2(index, 0);
+      }
+    ` : `
+      ivec2 getOutputCoords() {
+        ivec2 resTexRC = ivec2(resultUV.yx *
+                               vec2(${t[0]}, ${t[1]}));
+        int index = resTexRC.x * ${t[1]} + resTexRC.y;
+        return ivec2(index, 0);
+      }
+    ` : e[0] === 1 ? n ? `
+      ivec2 getOutputCoords() {
+        ivec2 resTexRC = ivec2(resultUV.yx *
+                               vec2(outTexShape[0], outTexShape[1]));
+        int index = resTexRC.x * outTexShape[1] + resTexRC.y;
+        return ivec2(0, index);
+      }
+    ` : `
+      ivec2 getOutputCoords() {
+        ivec2 resTexRC = ivec2(resultUV.yx *
+                               vec2(${t[0]}, ${t[1]}));
+        int index = resTexRC.x * ${t[1]} + resTexRC.y;
+        return ivec2(0, index);
+      }
+    ` : n ? `
+    ivec2 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(outTexShape[0], outTexShape[1]));
+      int index = resTexRC.x * outTexShape[1] + resTexRC.y;
+      int r = index / outShape[1];
+      int c = index - r * outShape[1];
+      return ivec2(r, c);
+    }
+  ` : `
+    ivec2 getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${t[0]}, ${t[1]}));
+      int index = resTexRC.x * ${t[1]} + resTexRC.y;
+      int r = index / ${e[1]};
+      int c = index - r * ${e[1]};
+      return ivec2(r, c);
+    }
+  `;
+}
+function U(e) {
+  return `offset${e}`;
+}
+function tt(e) {
+  const t = e.name, n = "get" + t.charAt(0).toUpperCase() + t.slice(1), r = L();
+  return `
+    vec4 ${n}() {
+      return ${r.texture2D}(${t}, halfCR);
+    }
+  `;
+}
+function nt(e, t) {
+  const n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1);
+  if (e.shapeInfo.isUniform)
+    return `float ${r}() {return ${n};}`;
+  const [o, i] = e.shapeInfo.texShape;
+  if (o === 1 && i === 1)
+    return `
+      float ${r}() {
+        return sampleTexture(${n}, halfCR);
+      }
+    `;
+  const a = U(n);
+  if (t)
+    return `
+    float ${r}() {
+      vec2 uv = uvFromFlat(${n}TexShape[0], ${n}TexShape[1], ${a});
+      return sampleTexture(${n}, uv);
+    }
+  `;
+  const [s, c] = e.shapeInfo.texShape;
+  return `
+    float ${r}() {
+      vec2 uv = uvFromFlat(${s}, ${c}, ${a});
+      return sampleTexture(${n}, uv);
+    }
+  `;
+}
+function rt(e, t) {
+  const n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1), o = e.shapeInfo.texShape, i = L();
+  if (t)
+    return `
+    vec4 ${r}(int index) {
+      ivec2 packedTexShape = ivec2(ceil(float(${n}TexShape[0]) / 2.0), ceil(float(${n}TexShape[1]) / 2.0));
+      vec2 uv = packedUVfrom1D(
+        packedTexShape[0], packedTexShape[1], index);
+      return ${i.texture2D}(${n}, uv);
+    }
+  `;
+  const a = [Math.ceil(o[0] / 2), Math.ceil(o[1] / 2)];
+  return `
+    vec4 ${r}(int index) {
+      vec2 uv = packedUVfrom1D(
+        ${a[0]}, ${a[1]}, index);
+      return ${i.texture2D}(${n}, uv);
+    }
+  `;
+}
+function ot(e, t) {
+  const n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1);
+  if (e.shapeInfo.isUniform)
+    return `
+      float ${r}(int index) {
+        ${D(e)}
+      }
+    `;
+  const o = e.shapeInfo.texShape, i = o[0], a = o[1];
+  if (a === 1 && i === 1)
+    return `
+      float ${r}(int index) {
+        return sampleTexture(${n}, halfCR);
+      }
+    `;
+  const s = U(n);
+  return a === 1 ? t ? `
+      float ${r}(int index) {
+        vec2 uv = vec2(0.5, (float(index + ${s}) + 0.5) / float(${n}TexShape[0]));
+        return sampleTexture(${n}, uv);
+      }
+    ` : `
+      float ${r}(int index) {
+        vec2 uv = vec2(0.5, (float(index + ${s}) + 0.5) / ${i}.0);
+        return sampleTexture(${n}, uv);
+      }
+    ` : i === 1 ? t ? `
+      float ${r}(int index) {
+        vec2 uv = vec2((float(index + ${s}) + 0.5) / float(${n}TexShape[1]), 0.5);
+        return sampleTexture(${n}, uv);
+      }
+    ` : `
+      float ${r}(int index) {
+        vec2 uv = vec2((float(index + ${s}) + 0.5) / ${a}.0, 0.5);
+        return sampleTexture(${n}, uv);
+      }
+    ` : t ? `
+    float ${r}(int index) {
+      vec2 uv = uvFromFlat(${n}TexShape[0], ${n}TexShape[1], index + ${s});
+      return sampleTexture(${n}, uv);
+    }
+  ` : `
+    float ${r}(int index) {
+      vec2 uv = uvFromFlat(${i}, ${a}, index + ${s});
+      return sampleTexture(${n}, uv);
+    }
+  `;
+}
+function it(e, t) {
+  const n = e.shapeInfo.logicalShape, r = e.name, o = "get" + r.charAt(0).toUpperCase() + r.slice(1), i = e.shapeInfo.texShape, a = i[0], s = i[1], c = L();
+  if (i != null && T(n, i))
+    return t ? `
+      vec4 ${o}(int row, int col) {
+        vec2 uv = (vec2(col, row) + halfCR) / vec2(${r}TexShape[1], ${r}TexShape[0]);
+
+        return ${c.texture2D}(${r}, uv);
+      }
+    ` : `
+      vec4 ${o}(int row, int col) {
+        vec2 uv = (vec2(col, row) + halfCR) / vec2(${s}.0, ${a}.0);
+
+        return ${c.texture2D}(${r}, uv);
+      }
+    `;
+  if (t)
+    return `
+    vec4 ${o}(int row, int col) {
+      ivec2 packedTexShape = ivec2(ceil(float(${r}TexShape[0]) / 2.0), ceil(float(${r}TexShape[1]) / 2.0));
+      int valuesPerRow = int(ceil(float(${r}Shape[1]) / 2.0));
+      vec2 uv = packedUVfrom2D(valuesPerRow, packedTexShape[0], packedTexShape[1], row, col);
+      return ${c.texture2D}(${r}, uv);
+    }
+  `;
+  const u = [Math.ceil(i[0] / 2), Math.ceil(i[1] / 2)], l = Math.ceil(n[1] / 2);
+  return `
+    vec4 ${o}(int row, int col) {
+      vec2 uv = packedUVfrom2D(${l}, ${u[0]}, ${u[1]}, row, col);
+      return ${c.texture2D}(${r}, uv);
+    }
+  `;
+}
+function at(e, t) {
+  const n = e.shapeInfo.logicalShape, r = e.name, o = "get" + r.charAt(0).toUpperCase() + r.slice(1), i = e.shapeInfo.texShape;
+  if (i != null && T(n, i)) {
+    if (t)
+      return `
+      float ${o}(int row, int col) {
+        vec2 uv = (vec2(col, row) + halfCR) / vec2(${r}TexShape[1], ${r}TexShape[0]);
+        return sampleTexture(${r}, uv);
+      }
+    `;
+    const d = i[0], h = i[1];
+    return `
+    float ${o}(int row, int col) {
+      vec2 uv = (vec2(col, row) + halfCR) / vec2(${h}.0, ${d}.0);
+      return sampleTexture(${r}, uv);
+    }
+  `;
+  }
+  const { newShape: a, keptDims: s } = I(n), c = a;
+  if (c.length < n.length) {
+    const d = y(e, c), h = ["row", "col"];
+    return `
+      ${b(d, t)}
+      float ${o}(int row, int col) {
+        return ${o}(${M(h, s)});
+      }
+    `;
+  }
+  if (e.shapeInfo.isUniform)
+    return `
+      float ${o}(int row, int col) {
+        int index = round(dot(vec2(row, col), vec2(${n[1]}, 1)));
+        ${D(e)}
+      }
+    `;
+  const u = i[0], l = i[1], f = U(r);
+  return l === 1 ? t ? `
+      float ${o}(int row, int col) {
+        float index = dot(vec3(row, col, ${f}), vec3(${r}Shape[1], 1, 1));
+        vec2 uv = vec2(0.5, (index + 0.5) / float(${r}TexShape[0]));
+        return sampleTexture(${r}, uv);
+      }
+    ` : `
+    float ${o}(int row, int col) {
+      float index = dot(vec3(row, col, ${f}), vec3(${n[1]}, 1, 1));
+      vec2 uv = vec2(0.5, (index + 0.5) / ${u}.0);
+      return sampleTexture(${r}, uv);
+    }
+  ` : u === 1 ? t ? `
+      float ${o}(int row, int col) {
+        float index = dot(vec3(row, col, ${f}), vec3(${r}Shape[1], 1, 1));
+        vec2 uv = vec2((index + 0.5) / float(${r}TexShape[1]), 0.5);
+        return sampleTexture(${r}, uv);
+      }
+    ` : `
+    float ${o}(int row, int col) {
+      float index = dot(vec3(row, col, ${f}), vec3(${n[1]}, 1, 1));
+      vec2 uv = vec2((index + 0.5) / ${l}.0, 0.5);
+      return sampleTexture(${r}, uv);
+    }
+  ` : t ? `
+      float ${o}(int row, int col) {
+        // Explicitly use integer operations as dot() only works on floats.
+        int index = row * ${r}Shape[1] + col + ${f};
+        vec2 uv = uvFromFlat(${r}TexShape[0], ${r}TexShape[1], index);
+        return sampleTexture(${r}, uv);
+      }
+    ` : `
+  float ${o}(int row, int col) {
+    // Explicitly use integer operations as dot() only works on floats.
+    int index = row * ${n[1]} + col + ${f};
+    vec2 uv = uvFromFlat(${u}, ${l}, index);
+    return sampleTexture(${r}, uv);
+  }
+`;
+}
+function ct(e, t) {
+  const n = e.shapeInfo.logicalShape, r = e.name, o = "get" + r.charAt(0).toUpperCase() + r.slice(1), i = e.shapeInfo.texShape, a = [Math.ceil(i[0] / 2), Math.ceil(i[1] / 2)];
+  if (n[0] === 1) {
+    const d = n.slice(1), h = [1, 2], x = y(e, d), p = ["b", "row", "col"];
+    return `
+        ${le(x, t)}
+        vec4 ${o}(int b, int row, int col) {
+          return ${o}(${M(p, h)});
+        }
+      `;
+  }
+  const s = L();
+  if (t)
+    return `
+    vec4 ${o}(int b, int row, int col) {
+      ivec2 packedTexShape = ivec2(ceil(float(${r}TexShape[0]) / 2.0), ceil(float(${r}TexShape[1]) / 2.0));
+      int valuesPerRow = int(ceil(float(${r}Shape[2]) / 2.0));
+      int texelsInBatch = valuesPerRow * int(ceil(float(${r}Shape[1]) / 2.0));
+      vec2 uv = packedUVfrom3D(
+        packedTexShape[0], packedTexShape[1], texelsInBatch, valuesPerRow, b, row, col);
+      return ${s.texture2D}(${r}, uv);
+    }
+  `;
+  const c = a[0], u = a[1], l = Math.ceil(n[2] / 2), f = l * Math.ceil(n[1] / 2);
+  return `
+    vec4 ${o}(int b, int row, int col) {
+      vec2 uv = packedUVfrom3D(
+        ${c}, ${u}, ${f}, ${l}, b, row, col);
+      return ${s.texture2D}(${r}, uv);
+    }
+  `;
+}
+function st(e, t) {
+  const n = e.shapeInfo.logicalShape, r = e.name, o = "get" + r.charAt(0).toUpperCase() + r.slice(1), i = n[1] * n[2], a = n[2], { newShape: s, keptDims: c } = I(n), u = s;
+  if (u.length < n.length) {
+    const p = y(e, u), $ = ["row", "col", "depth"];
+    return `
+        ${b(p, t)}
+        float ${o}(int row, int col, int depth) {
+          return ${o}(${M($, c)});
+        }
+      `;
+  }
+  if (e.shapeInfo.isUniform)
+    return `
+      float ${o}(int row, int col, int depth) {
+        int index = round(dot(vec3(row, col, depth),
+                          vec3(${i}, ${a}, 1)));
+        ${D(e)}
+      }
+    `;
+  const l = e.shapeInfo.texShape, f = l[0], d = l[1], h = e.shapeInfo.flatOffset;
+  if (d === i && h == null)
+    return t ? `
+      float ${o}(int row, int col, int depth) {
+        int stride1 = ${r}Shape[2];
+        float texR = float(row);
+        float texC = dot(vec2(col, depth), vec2(stride1, 1));
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                   vec2(${r}TexShape[1], ${r}TexShape[0]);
+        return sampleTexture(${r}, uv);
+      }
+    ` : `
+        float ${o}(int row, int col, int depth) {
+          float texR = float(row);
+          float texC = dot(vec2(col, depth), vec2(${a}, 1));
+          vec2 uv = (vec2(texC, texR) + halfCR) /
+                     vec2(${d}.0, ${f}.0);
+          return sampleTexture(${r}, uv);
+        }
+      `;
+  if (d === a && h == null)
+    return t ? `
+      float ${o}(int row, int col, int depth) {
+        float texR = dot(vec2(row, col), vec2(${r}Shape[1], 1));
+        float texC = float(depth);
+        vec2 uv = (vec2(texC, texR) + halfCR) / vec2(${r}TexShape[1], ${r}TexShape[0]);
+        return sampleTexture(${r}, uv);
+      }
+    ` : `
+    float ${o}(int row, int col, int depth) {
+      float texR = dot(vec2(row, col), vec2(${n[1]}, 1));
+      float texC = float(depth);
+      vec2 uv = (vec2(texC, texR) + halfCR) / vec2(${d}.0, ${f}.0);
+      return sampleTexture(${r}, uv);
+    }
+  `;
+  const x = U(r);
+  return t ? `
+    float ${o}(int row, int col, int depth) {
+      // Explicitly use integer operations as dot() only works on floats.
+      int stride0 = ${r}Shape[1] * ${r}Shape[2];
+      int stride1 = ${r}Shape[2];
+      int index = row * stride0 + col * stride1 + depth + ${x};
+      vec2 uv = uvFromFlat(${r}TexShape[0], ${r}TexShape[1], index);
+      return sampleTexture(${r}, uv);
+    }
+    ` : `
+      float ${o}(int row, int col, int depth) {
+        // Explicitly use integer operations as dot() only works on floats.
+        int index = row * ${i} + col * ${a} + depth + ${x};
+        vec2 uv = uvFromFlat(${f}, ${d}, index);
+        return sampleTexture(${r}, uv);
+      }
+  `;
+}
+function ut(e, t) {
+  const n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1), o = L();
+  if (t)
+    return `
+    vec4 ${r}(int b2, int b, int row, int col) {
+      int valuesPerRow = int(ceil(float(${n}Shape[3]) / 2.0));
+      int texelsInBatch = valuesPerRow * int(ceil(float(${n}Shape[2]) / 2.0));
+      int index = b * texelsInBatch + (row / 2) * valuesPerRow + (col / 2);
+      texelsInBatch *= ${n}Shape[1];
+      index = b2 * texelsInBatch + index;
+      ivec2 packedTexShape = ivec2(ceil(float(${n}TexShape[0]) / 2.0), ceil(float(${n}TexShape[1]) / 2.0));
+      int texR = index / packedTexShape[1];
+      int texC = index - texR * packedTexShape[1];
+      vec2 uv = (vec2(texC, texR) + halfCR) / vec2(packedTexShape[1], packedTexShape[0]); return ${o.texture2D}(${n}, uv);
+    }
+  `;
+  const i = e.shapeInfo.logicalShape, a = i.length, s = e.shapeInfo.texShape, c = [Math.ceil(s[0] / 2), Math.ceil(s[1] / 2)], u = c[0], l = c[1], f = Math.ceil(i[a - 1] / 2);
+  let d = f * Math.ceil(i[a - 2] / 2), h = "int b, int row, int col", x = `b * ${d} + (row / 2) * ${f} + (col / 2)`;
+  for (let p = 2; p < a - 1; p++)
+    h = `int b${p}, ` + h, d *= i[a - p - 1], x = `b${p} * ${d} + ` + x;
+  return `
+    vec4 ${r}(${h}) {
+      int index = ${x};
+      int texR = index / ${l};
+      int texC = index - texR * ${l};
+      vec2 uv = (vec2(texC, texR) + halfCR) / vec2(${l}, ${u});
+      return ${o.texture2D}(${n}, uv);
+    }
+  `;
+}
+function lt(e, t) {
+  const n = e.shapeInfo.logicalShape, r = e.name, o = "get" + r.charAt(0).toUpperCase() + r.slice(1), i = n[3], a = n[2] * i, s = n[1] * a, { newShape: c, keptDims: u } = I(n);
+  if (c.length < n.length) {
+    const R = y(e, c), w = ["row", "col", "depth", "depth2"];
+    return `
+      ${b(R, t)}
+      float ${o}(int row, int col, int depth, int depth2) {
+        return ${o}(${M(w, u)});
+      }
+    `;
+  }
+  if (e.shapeInfo.isUniform)
+    return `
+      float ${o}(int row, int col, int depth, int depth2) {
+        int index = round(dot(vec4(row, col, depth, depth2),
+                          vec4(${s}, ${a}, ${i}, 1)));
+        ${D(e)}
+      }
+    `;
+  const l = e.shapeInfo.flatOffset, f = e.shapeInfo.texShape, d = f[0], h = f[1], x = `int stride2 = ${r}Shape[3];`, p = `int stride1 = ${r}Shape[2] * stride2;`, $ = `int stride0 = ${r}Shape[1] * stride1;`;
+  if (h === s && l == null)
+    return t ? `
+      float ${o}(int row, int col, int depth, int depth2) {
+        ${x}
+        ${p}
+        float texR = float(row);
+        float texC =
+            dot(vec3(col, depth, depth2),
+                vec3(stride1, stride2, 1));
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                   vec2(${r}TexShape[1], ${r}TexShape[0]);
+        return sampleTexture(${r}, uv);
+      }
+    ` : `
+      float ${o}(int row, int col, int depth, int depth2) {
+        float texR = float(row);
+        float texC =
+            dot(vec3(col, depth, depth2),
+                vec3(${a}, ${i}, 1));
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                   vec2(${h}.0, ${d}.0);
+        return sampleTexture(${r}, uv);
+      }
+    `;
+  if (h === i && l == null)
+    return t ? `
+      float ${o}(int row, int col, int depth, int depth2) {
+        float texR = dot(vec3(row, col, depth),
+                         vec3(${r}Shape[1] * ${r}Shape[2], ${r}Shape[2], 1));
+        float texC = float(depth2);
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                  vec2(${r}TexShape[1], ${r}TexShape[0]);
+        return sampleTexture(${r}, uv);
+      }
+    ` : `
+      float ${o}(int row, int col, int depth, int depth2) {
+        float texR = dot(vec3(row, col, depth),
+                         vec3(${n[1] * n[2]}, ${n[2]}, 1));
+        float texC = float(depth2);
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                  vec2(${h}.0, ${d}.0);
+        return sampleTexture(${r}, uv);
+      }
+    `;
+  const S = U(r);
+  return t ? `
+    float ${o}(int row, int col, int depth, int depth2) {
+      // Explicitly use integer operations as dot() only works on floats.
+      ${x}
+      ${p}
+      ${$}
+      int index = row * stride0 + col * stride1 +
+          depth * stride2 + depth2;
+      vec2 uv = uvFromFlat(${r}TexShape[0], ${r}TexShape[1], index + ${S});
+      return sampleTexture(${r}, uv);
+    }
+  ` : `
+    float ${o}(int row, int col, int depth, int depth2) {
+      // Explicitly use integer operations as dot() only works on floats.
+      int index = row * ${s} + col * ${a} +
+          depth * ${i} + depth2;
+      vec2 uv = uvFromFlat(${d}, ${h}, index + ${S});
+      return sampleTexture(${r}, uv);
+    }
+  `;
+}
+function ft(e) {
+  const t = e.shapeInfo.logicalShape, n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1), o = t[4], i = t[3] * o, a = t[2] * i, s = t[1] * a, { newShape: c, keptDims: u } = I(t);
+  if (c.length < t.length) {
+    const p = y(e, c), $ = ["row", "col", "depth", "depth2", "depth3"];
+    return `
+      ${b(p)}
+      float ${r}(int row, int col, int depth, int depth2, int depth3) {
+        return ${r}(${M($, u)});
+      }
+    `;
+  }
+  if (e.shapeInfo.isUniform)
+    return `
+      float ${r}(int row, int col, int depth, int depth2, int depth3) {
+        float index = dot(
+          vec4(row, col, depth, depth2),
+          vec4(${s}, ${a}, ${i}, ${o})) +
+          depth3;
+        ${D(e)}
+      }
+    `;
+  const l = e.shapeInfo.flatOffset, f = e.shapeInfo.texShape, d = f[0], h = f[1];
+  if (h === s && l == null)
+    return `
+      float ${r}(int row, int col, int depth, int depth2, int depth3) {
+        int texR = row;
+        float texC = dot(vec4(col, depth, depth2, depth3),
+                         vec4(${a}, ${i}, ${o}, 1));
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                   vec2(${h}.0, ${d}.0);
+        return sampleTexture(${n}, uv);
+      }
+    `;
+  if (h === o && l == null)
+    return `
+      float ${r}(int row, int col, int depth, int depth2, int depth3) {
+        float texR = dot(
+          vec4(row, col, depth, depth2),
+          vec4(${t[1] * t[2] * t[3]},
+               ${t[2] * t[3]}, ${t[3]}, 1));
+        int texC = depth3;
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                  vec2(${h}.0, ${d}.0);
+        return sampleTexture(${n}, uv);
+      }
+    `;
+  const x = U(n);
+  return `
+    float ${r}(int row, int col, int depth, int depth2, int depth3) {
+      // Explicitly use integer operations as dot() only works on floats.
+      int index = row * ${s} + col * ${a} + depth * ${i} +
+          depth2 * ${o} + depth3 + ${x};
+      vec2 uv = uvFromFlat(${d}, ${h}, index);
+      return sampleTexture(${n}, uv);
+    }
+  `;
+}
+function ht(e) {
+  const t = e.shapeInfo.logicalShape, n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1), { newShape: o, keptDims: i } = I(t);
+  if (o.length < t.length) {
+    const $ = y(e, o), S = ["row", "col", "depth", "depth2", "depth3", "depth4"];
+    return `
+      ${b($)}
+      float ${r}(int row, int col, int depth,
+                    int depth2, int depth3, int depth4) {
+        return ${r}(${M(S, i)});
+      }
+    `;
+  }
+  const a = t[5], s = t[4] * a, c = t[3] * s, u = t[2] * c, l = t[1] * u;
+  if (e.shapeInfo.isUniform)
+    return `
+      float ${r}(int row, int col, int depth,
+                  int depth2, int depth3, int depth4) {
+        int index = round(dot(
+          vec4(row, col, depth, depth2),
+          vec4(${l}, ${u}, ${c}, ${s})) +
+          dot(
+            vec2(depth3, depth4),
+            vec2(${a}, 1)));
+        ${D(e)}
+      }
+    `;
+  const f = e.shapeInfo.flatOffset, d = e.shapeInfo.texShape, h = d[0], x = d[1];
+  if (x === l && f == null)
+    return `
+      float ${r}(int row, int col, int depth,
+                    int depth2, int depth3, int depth4) {
+        int texR = row;
+        float texC = dot(vec4(col, depth, depth2, depth3),
+          vec4(${u}, ${c}, ${s}, ${a})) +
+               float(depth4);
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                   vec2(${x}.0, ${h}.0);
+        return sampleTexture(${n}, uv);
+      }
+    `;
+  if (x === a && f == null)
+    return `
+      float ${r}(int row, int col, int depth,
+                    int depth2, int depth3, int depth4) {
+        float texR = dot(vec4(row, col, depth, depth2),
+          vec4(${t[1] * t[2] * t[3] * t[4]},
+               ${t[2] * t[3] * t[4]},
+               ${t[3] * t[4]},
+               ${t[4]})) + float(depth3);
+        int texC = depth4;
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                  vec2(${x}.0, ${h}.0);
+        return sampleTexture(${n}, uv);
+      }
+    `;
+  const p = U(n);
+  return `
+    float ${r}(int row, int col, int depth,
+                  int depth2, int depth3, int depth4) {
+      // Explicitly use integer operations as dot() only works on floats.
+      int index = row * ${l} + col * ${u} + depth * ${c} +
+          depth2 * ${s} + depth3 * ${a} + depth4 + ${p};
+      vec2 uv = uvFromFlat(${h}, ${x}, index);
+      return sampleTexture(${n}, uv);
+    }
+  `;
+}
+function D(e) {
+  const t = e.name, n = E(e.shapeInfo.logicalShape);
+  return n < 2 ? `return ${t};` : `
+    for (int i = 0; i < ${n}; i++) {
+      if (i == index) {
+        return ${t}[i];
+      }
+    }
+  `;
+}
+function dt(e, t) {
+  const n = e.name, r = n.charAt(0).toUpperCase() + n.slice(1), o = "get" + r + "AtOutCoords", i = e.shapeInfo.logicalShape.length, a = t.logicalShape.length, s = ue(e.shapeInfo.logicalShape, t.logicalShape), c = he(a), u = a - i;
+  let l;
+  const f = ["x", "y", "z", "w", "u", "v"];
+  i === 0 ? l = "" : a < 2 && s.length >= 1 ? l = "coords = 0;" : l = s.map((R) => `coords.${f[R + u]} = 0;`).join(`
+`);
+  let d = "";
+  a < 2 && i > 0 ? d = "coords" : d = e.shapeInfo.logicalShape.map((R, w) => `coords.${f[w + u]}`).join(", ");
+  let h = "return outputValue;";
+  const p = E(e.shapeInfo.logicalShape) === 1, S = E(t.logicalShape) === 1;
+  if (i === 1 && !p && !S)
+    h = `
+      return vec4(outputValue.xy, outputValue.xy);
+    `;
+  else if (p && !S)
+    a === 1 ? h = `
+        return vec4(outputValue.x, outputValue.x, 0., 0.);
+      ` : h = `
+        return vec4(outputValue.x);
+      `;
+  else if (s.length) {
+    const R = i - 2, w = i - 1;
+    s.indexOf(R) > -1 && s.indexOf(w) > -1 ? h = "return vec4(outputValue.x);" : s.indexOf(R) > -1 ? h = "return vec4(outputValue.x, outputValue.y, outputValue.x, outputValue.y);" : s.indexOf(w) > -1 && (h = "return vec4(outputValue.xx, outputValue.zz);");
+  }
+  return `
+    vec4 ${o}() {
+      ${c} coords = getOutputCoords();
+      ${l}
+      vec4 outputValue = get${r}(${d});
+      ${h}
+    }
+  `;
+}
+function xt(e, t) {
+  const n = e.name, r = n.charAt(0).toUpperCase() + n.slice(1), o = "get" + r + "AtOutCoords", i = t.texShape, a = e.shapeInfo.texShape, s = e.shapeInfo.logicalShape.length, c = t.logicalShape.length;
+  if (!e.shapeInfo.isUniform && s === c && e.shapeInfo.flatOffset == null && T(a, i))
+    return `
+      float ${o}() {
+        return sampleTexture(${n}, resultUV);
+      }
+    `;
+  const u = he(c), l = ue(e.shapeInfo.logicalShape, t.logicalShape), f = c - s;
+  let d;
+  const h = ["x", "y", "z", "w", "u", "v"];
+  s === 0 ? d = "" : c < 2 && l.length >= 1 ? d = "coords = 0;" : d = l.map((p) => `coords.${h[p + f]} = 0;`).join(`
+`);
+  let x = "";
+  return c < 2 && s > 0 ? x = "coords" : x = e.shapeInfo.logicalShape.map((p, $) => `coords.${h[$ + f]}`).join(", "), `
+    float ${o}() {
+      ${u} coords = getOutputCoords();
+      ${d}
+      return get${r}(${x});
+    }
+  `;
+}
+function he(e) {
+  if (e <= 1)
+    return "int";
+  if (e === 2)
+    return "ivec2";
+  if (e === 3)
+    return "ivec3";
+  if (e === 4)
+    return "ivec4";
+  if (e === 5)
+    return "ivec5";
+  if (e === 6)
+    return "ivec6";
+  throw Error(`GPU for rank ${e} is not yet supported`);
+}
+function j(e, t, n) {
+  const { newShape: r, keptDims: o } = I(t), i = t.length, a = e && i === 3 && t[0] === 1, s = a ? t.slice(1) : r, c = !e && i > 1 && !T(t, n) && r.length < i || a;
+  return { useSqueezeShape: c, uniformShape: c ? s : t, keptDims: o };
+}
+function y(e, t) {
+  const n = JSON.parse(JSON.stringify(e));
+  return n.shapeInfo.logicalShape = t, n;
+}
+function M(e, t) {
+  return t.map((n) => e[n]).join(", ");
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const _ = {}, k = {
+  alpha: !1,
+  antialias: !1,
+  premultipliedAlpha: !1,
+  preserveDrawingBuffer: !1,
+  depth: !1,
+  stencil: !1,
+  failIfMajorPerformanceCaveat: !0
+};
+function Mt(e, t) {
+  _[e] = t;
+}
+function A(e, t) {
+  if (!(e in _) || t != null) {
+    const r = vt(e, t);
+    if (r !== null)
+      _[e] = r;
+    else
+      return console.log("Could not get context for WebGL version", e), null;
+  }
+  const n = _[e];
+  return n == null || n.isContextLost() ? (delete _[e], A(e)) : (n.disable(n.DEPTH_TEST), n.disable(n.STENCIL_TEST), n.disable(n.BLEND), n.disable(n.DITHER), n.disable(n.POLYGON_OFFSET_FILL), n.disable(n.SAMPLE_COVERAGE), n.enable(n.SCISSOR_TEST), n.enable(n.CULL_FACE), n.cullFace(n.BACK), _[e]);
+}
+function pt(e) {
+  if (!v().getBool("IS_SAFARI") && typeof OffscreenCanvas < "u" && e === 2)
+    return new OffscreenCanvas(300, 150);
+  if (typeof document < "u")
+    return document.createElement("canvas");
+  throw new Error("Cannot create a canvas in this context");
+}
+function vt(e, t) {
+  if (e !== 1 && e !== 2)
+    throw new Error("Cannot get WebGL rendering context, WebGL is disabled.");
+  const n = t ?? pt(e);
+  return n.addEventListener("webglcontextlost", (r) => {
+    r.preventDefault(), delete _[e];
+  }, !1), v().getBool("SOFTWARE_WEBGL_ENABLED") && (k.failIfMajorPerformanceCaveat = !1), e === 1 ? (
+    // tslint:disable-next-line
+    n.getContext("webgl", k) || n.getContext("experimental-webgl", k)
+  ) : n.getContext("webgl2", k);
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+var ee;
+(function(e) {
+  e[e.DENSE = 0] = "DENSE", e[e.SHARED_BATCH = 1] = "SHARED_BATCH";
+})(ee || (ee = {}));
+var te;
+(function(e) {
+  e[e.RENDER = 0] = "RENDER", e[e.UPLOAD = 1] = "UPLOAD", e[e.PIXELS = 2] = "PIXELS", e[e.DOWNLOAD = 3] = "DOWNLOAD";
+})(te || (te = {}));
+var ne;
+(function(e) {
+  e[e.UNPACKED_FLOAT16 = 0] = "UNPACKED_FLOAT16", e[e.UNPACKED_FLOAT32 = 1] = "UNPACKED_FLOAT32", e[e.PACKED_4X1_UNSIGNED_BYTE = 2] = "PACKED_4X1_UNSIGNED_BYTE", e[e.PACKED_2X2_FLOAT32 = 3] = "PACKED_2X2_FLOAT32", e[e.PACKED_2X2_FLOAT16 = 4] = "PACKED_2X2_FLOAT16";
+})(ne || (ne = {}));
+function Bt(e, t) {
+  return [t, e];
+}
+function kt(e, t) {
+  return e * t;
+}
+function Pt(e) {
+  const t = E(e), n = Math.ceil(t / 4);
+  return H(n);
+}
+function mt(e, t) {
+  return [
+    Math.max(1, Math.ceil(t / 2)),
+    Math.max(1, Math.ceil(e / 2))
+  ];
+}
+function Vt(e, t) {
+  const [n, r] = mt(e, t);
+  return n * r * 4;
+}
+function de(e, t) {
+  const n = e;
+  let r, o, i, a, s, c, u, l, f, d;
+  return v().getNumber("WEBGL_VERSION") === 2 ? (r = n.R32F, o = n.R16F, i = n.RGBA16F, a = n.RGBA32F, s = n.RED, u = 4, l = 1, f = n.HALF_FLOAT, d = n.FLOAT, c = n.RGBA8) : (r = e.RGBA, o = e.RGBA, i = e.RGBA, a = n.RGBA, s = e.RGBA, u = 4, l = 4, f = t != null ? t.HALF_FLOAT_OES : null, d = e.FLOAT, c = e.RGBA), {
+    internalFormatFloat: r,
+    internalFormatHalfFloat: o,
+    internalFormatPackedHalfFloat: i,
+    internalFormatPackedFloat: a,
+    textureFormatFloat: s,
+    downloadTextureFormat: c,
+    downloadUnpackNumChannels: u,
+    defaultNumChannels: l,
+    textureTypeHalfFloat: f,
+    textureTypeFloat: d
+  };
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function m(e, t) {
+  const n = t();
+  return v().getBool("DEBUG") && $t(e), n;
+}
+function $t(e) {
+  const t = e.getError();
+  if (t !== e.NO_ERROR)
+    throw new Error("WebGL Error: " + Rt(e, t));
+}
+const Tt = 596e-10, St = 65504;
+function Wt(e) {
+  return !!(v().getBool("WEBGL_RENDER_FLOAT32_ENABLED") || e === 0 || Tt < Math.abs(e) && Math.abs(e) < St);
+}
+function Rt(e, t) {
+  switch (t) {
+    case e.NO_ERROR:
+      return "NO_ERROR";
+    case e.INVALID_ENUM:
+      return "INVALID_ENUM";
+    case e.INVALID_VALUE:
+      return "INVALID_VALUE";
+    case e.INVALID_OPERATION:
+      return "INVALID_OPERATION";
+    case e.INVALID_FRAMEBUFFER_OPERATION:
+      return "INVALID_FRAMEBUFFER_OPERATION";
+    case e.OUT_OF_MEMORY:
+      return "OUT_OF_MEMORY";
+    case e.CONTEXT_LOST_WEBGL:
+      return "CONTEXT_LOST_WEBGL";
+    default:
+      return `Unknown error code ${t}`;
+  }
+}
+function Xt(e, t) {
+  return C(e, () => e.getExtension(t), 'Extension "' + t + '" not supported on this browser.');
+}
+function Ht(e, t) {
+  const n = C(e, () => e.createShader(e.VERTEX_SHADER), "Unable to create vertex WebGLShader.");
+  if (m(e, () => e.shaderSource(n, t)), m(e, () => e.compileShader(n)), e.getShaderParameter(n, e.COMPILE_STATUS) === !1)
+    throw console.log(e.getShaderInfoLog(n)), new Error("Failed to compile vertex shader.");
+  return n;
+}
+function Et(e, t) {
+  const n = C(e, () => e.createShader(e.FRAGMENT_SHADER), "Unable to create fragment WebGLShader.");
+  if (m(e, () => e.shaderSource(n, t)), m(e, () => e.compileShader(n)), v().get("ENGINE_COMPILE_ONLY"))
+    return n;
+  if (e.getShaderParameter(n, e.COMPILE_STATUS) === !1)
+    throw wt(t, e.getShaderInfoLog(n)), new Error("Failed to compile fragment shader.");
+  return n;
+}
+const Ct = /ERROR: [0-9]+:([0-9]+):/g;
+function wt(e, t) {
+  const n = Ct.exec(t);
+  if (n == null) {
+    console.log(`Couldn't parse line number in error: ${t}`), console.log(e);
+    return;
+  }
+  const r = +n[1], o = e.split(`
+`), i = o.length.toString().length + 2, a = o.map((f, d) => Y((d + 1).toString(), i) + f);
+  let s = 0;
+  for (let f = 0; f < a.length; f++)
+    s = Math.max(a[f].length, s);
+  const c = a.slice(0, r - 1), u = a.slice(r - 1, r), l = a.slice(r);
+  console.log(c.join(`
+`)), console.log(t.split(`
+`)[0]), console.log(`%c ${Y(u[0], s)}`, "border:1px solid red; background-color:#e3d2d2; color:#a61717"), console.log(l.join(`
+`));
+}
+function Gt(e) {
+  return C(e, () => e.createProgram(), "Unable to create WebGLProgram.");
+}
+function zt(e, t) {
+  if (m(e, () => e.linkProgram(t)), !v().get("ENGINE_COMPILE_ONLY") && e.getProgramParameter(t, e.LINK_STATUS) === !1)
+    throw console.log(e.getProgramInfoLog(t)), new Error("Failed to link vertex and fragment shaders.");
+}
+function qt(e, t) {
+  if (m(e, () => e.validateProgram(t)), e.getProgramParameter(t, e.VALIDATE_STATUS) === !1)
+    throw console.log(e.getProgramInfoLog(t)), new Error("Shader program validation failed.");
+}
+function jt(e, t) {
+  const n = C(e, () => e.createBuffer(), "Unable to create WebGLBuffer");
+  return m(e, () => e.bindBuffer(e.ARRAY_BUFFER, n)), m(e, () => e.bufferData(e.ARRAY_BUFFER, t, e.STATIC_DRAW)), n;
+}
+function Jt(e, t) {
+  const n = C(e, () => e.createBuffer(), "Unable to create WebGLBuffer");
+  return m(e, () => e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, n)), m(e, () => e.bufferData(e.ELEMENT_ARRAY_BUFFER, t, e.STATIC_DRAW)), n;
+}
+function Yt(e) {
+  return C(e, () => e.createTexture(), "Unable to create WebGLTexture.");
+}
+function Kt(e, t) {
+  const n = v().getNumber("WEBGL_MAX_TEXTURE_SIZE");
+  if (e <= 0 || t <= 0) {
+    const r = `[${e}x${t}]`;
+    throw new Error("Requested texture size " + r + " is invalid.");
+  }
+  if (e > n || t > n) {
+    const r = `[${e}x${t}]`, o = `[${n}x${n}]`;
+    throw new Error("Requested texture size " + r + " greater than WebGL maximum on this browser / GPU " + o + ".");
+  }
+}
+function Zt(e) {
+  return C(e, () => e.createFramebuffer(), "Unable to create WebGLFramebuffer.");
+}
+function Qt(e, t, n, r, o, i, a) {
+  const s = e.getAttribLocation(t, n);
+  return s === -1 ? !1 : (m(e, () => e.bindBuffer(e.ARRAY_BUFFER, r)), m(e, () => e.vertexAttribPointer(s, o, e.FLOAT, !1, i, a)), m(e, () => e.enableVertexAttribArray(s)), !0);
+}
+function Ft(e, t, n) {
+  At(e, n), m(e, () => e.activeTexture(e.TEXTURE0 + n)), m(e, () => e.bindTexture(e.TEXTURE_2D, t));
+}
+function en(e, t, n) {
+  return C(e, () => e.getUniformLocation(t, n), 'uniform "' + n + '" not present in program.');
+}
+function tn(e, t, n) {
+  return e.getUniformLocation(t, n);
+}
+function nn(e, t, n, r) {
+  m(e, () => Ft(e, t, r)), m(e, () => e.uniform1i(n, r));
+}
+function rn(e, t, n) {
+  m(e, () => e.bindFramebuffer(e.FRAMEBUFFER, n)), m(e, () => e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, t, 0));
+}
+function on(e, t) {
+  m(e, () => e.bindFramebuffer(e.FRAMEBUFFER, t)), m(e, () => e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, null, 0));
+}
+function an(e) {
+  const t = e.checkFramebufferStatus(e.FRAMEBUFFER);
+  if (t !== e.FRAMEBUFFER_COMPLETE)
+    throw new Error("Error binding framebuffer: " + gt(e, t));
+}
+function gt(e, t) {
+  switch (t) {
+    case e.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+      return "FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
+    case e.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+      return "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
+    case e.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+      return "FRAMEBUFFER_INCOMPLETE_DIMENSIONS";
+    case e.FRAMEBUFFER_UNSUPPORTED:
+      return "FRAMEBUFFER_UNSUPPORTED";
+    default:
+      return `unknown error ${t}`;
+  }
+}
+function C(e, t, n) {
+  const r = m(e, () => t());
+  if (r == null)
+    throw new Error(n);
+  return r;
+}
+function At(e, t) {
+  const n = e.MAX_COMBINED_TEXTURE_IMAGE_UNITS - 1, r = t + e.TEXTURE0;
+  if (r < e.TEXTURE0 || r > n) {
+    const o = `[gl.TEXTURE0, gl.TEXTURE${n}]`;
+    throw new Error(`textureUnit must be in ${o}.`);
+  }
+}
+function xe(e, t = 2) {
+  return E(e.slice(0, e.length - t));
+}
+function pe(e) {
+  if (e.length === 0)
+    throw Error("Cannot get rows and columns of an empty shape array.");
+  return [
+    e.length > 1 ? e[e.length - 2] : 1,
+    e[e.length - 1]
+  ];
+}
+function cn(e) {
+  let t = [1, 1, 1];
+  return e.length === 0 || e.length === 1 && e[0] === 1 || (t = [xe(e), ...pe(e)]), t;
+}
+function sn(e, t = !1) {
+  let n = v().getNumber("WEBGL_MAX_TEXTURE_SIZE"), r = v().getNumber("WEBGL_MAX_SIZE_FOR_NARROW_TEXTURE");
+  r === 1 / 0 && v().getBool("WEBGL_AUTO_SQUARIFY_NARROW_TEXTURE_SHAPE") && (r = n / 2), t && (n = n * 2, r = r * 2, e = e.map((s, c) => c >= e.length - 2 ? $e(e[c]) : e[c]), e.length === 1 && (e = [2, e[0]])), e.length !== 2 && (e = I(e).newShape);
+  let o = E(e), i = null;
+  e.length <= 1 && o <= n ? i = [1, o] : e.length === 2 && e[0] <= n && e[1] <= n ? i = e : e.length === 3 && e[0] * e[1] <= n && e[2] <= n ? i = [e[0] * e[1], e[2]] : e.length === 3 && e[0] <= n && e[1] * e[2] <= n ? i = [e[0], e[1] * e[2]] : e.length === 4 && e[0] * e[1] * e[2] <= n && e[3] <= n ? i = [e[0] * e[1] * e[2], e[3]] : e.length === 4 && e[0] <= n && e[1] * e[2] * e[3] <= n && (i = [e[0], e[1] * e[2] * e[3]]);
+  const a = i != null && Math.max(...i) > r && Math.min(...i) <= (t ? 2 : 1) && Math.min(...i) > 0;
+  if (i == null || a)
+    if (t) {
+      const s = xe(e);
+      let c = 2, u = 2;
+      e.length && ([c, u] = pe(e)), o = s * (c / 2) * (u / 2), i = H(o).map((l) => l * 2);
+    } else
+      i = H(o);
+  return i;
+}
+function P(e) {
+  return e % 2 === 0;
+}
+function un(e, t) {
+  if (e = e.slice(-2), t = t.slice(-2), T(e, t) || !e.length || !t.length || e[0] === 0 || e[1] === 0 || t[0] === 0 || t[1] === 0)
+    return !0;
+  if (e.length !== t.length) {
+    const n = e[e.length - 1], r = t[t.length - 1];
+    if (n === r || P(n) && P(r) && (e[0] === 1 || t[0] === 1))
+      return !0;
+  }
+  return e[1] === t[1] && P(e[0]) && P(t[0]);
+}
+let W, X;
+function ln(e) {
+  if (W == null) {
+    const t = A(e);
+    W = t.getParameter(t.MAX_TEXTURE_SIZE);
+  }
+  return W;
+}
+function fn(e) {
+  if (X == null) {
+    const t = A(e);
+    X = t.getParameter(t.MAX_TEXTURE_IMAGE_UNITS);
+  }
+  return Math.min(16, X);
+}
+function hn(e) {
+  if (e === 0)
+    return 0;
+  let t;
+  const n = A(e);
+  return g(n, "EXT_disjoint_timer_query_webgl2") && e === 2 ? t = 2 : g(n, "EXT_disjoint_timer_query") ? t = 1 : t = 0, t;
+}
+function g(e, t) {
+  return e.getExtension(t) != null;
+}
+function dn(e) {
+  try {
+    if (A(e) != null)
+      return !0;
+  } catch (t) {
+    return console.log("Error when getting WebGL context: ", t), !1;
+  }
+  return !1;
+}
+function xn(e) {
+  if (e === 0)
+    return !1;
+  const t = A(e);
+  if (e === 1) {
+    if (!g(t, "OES_texture_float"))
+      return !1;
+  } else if (!g(t, "EXT_color_buffer_float"))
+    return !1;
+  return G(t);
+}
+function pn(e) {
+  if (e === 0)
+    return !1;
+  const t = A(e);
+  if (e === 1) {
+    if (!g(t, "OES_texture_float") || !g(t, "WEBGL_color_buffer_float"))
+      return !1;
+  } else {
+    if (g(t, "EXT_color_buffer_float"))
+      return G(t);
+    const r = "EXT_color_buffer_half_float";
+    if (g(t, r)) {
+      const o = t.getExtension(r);
+      return _t(t, o);
+    }
+    return !1;
+  }
+  return G(t);
+}
+function G(e) {
+  const t = de(e), n = e.createTexture();
+  e.bindTexture(e.TEXTURE_2D, n), e.texImage2D(e.TEXTURE_2D, 0, t.internalFormatFloat, 1, 1, 0, t.textureFormatFloat, t.textureTypeFloat, null);
+  const i = e.createFramebuffer();
+  e.bindFramebuffer(e.FRAMEBUFFER, i), e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, n, 0);
+  const a = e.checkFramebufferStatus(e.FRAMEBUFFER) === e.FRAMEBUFFER_COMPLETE;
+  return e.bindTexture(e.TEXTURE_2D, null), e.bindFramebuffer(e.FRAMEBUFFER, null), e.deleteTexture(n), e.deleteFramebuffer(i), a;
+}
+function _t(e, t) {
+  const n = de(e, t), r = e.createTexture();
+  e.bindTexture(e.TEXTURE_2D, r), e.texImage2D(e.TEXTURE_2D, 0, n.internalFormatHalfFloat, 1, 1, 0, n.textureFormatFloat, n.textureTypeHalfFloat, null);
+  const a = e.createFramebuffer();
+  e.bindFramebuffer(e.FRAMEBUFFER, a), e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, r, 0);
+  const s = e.checkFramebufferStatus(e.FRAMEBUFFER) === e.FRAMEBUFFER_COMPLETE;
+  return e.bindTexture(e.TEXTURE_2D, null), e.bindFramebuffer(e.FRAMEBUFFER, null), e.deleteTexture(r), e.deleteFramebuffer(a), s;
+}
+function vn(e) {
+  return e !== 2 ? !1 : A(e).fenceSync != null;
+}
+function mn(e, t) {
+  Array.isArray(e) || (e = [e]), e.forEach((n) => {
+    n != null && F(n.dtype !== "complex64", () => `${t} does not support complex64 tensors in the WebGL backend.`);
+  });
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function $n(e, t, n, r) {
+  const o = n.map((l, f) => {
+    const d = {
+      logicalShape: l.shape,
+      texShape: l.isUniform ? null : l.texData.texShape,
+      isUniform: l.isUniform,
+      isPacked: l.isUniform ? !1 : l.texData.isPacked,
+      flatOffset: null
+    };
+    return l.texData != null && l.texData.slice != null && l.texData.slice.flatOffset > 0 && (d.flatOffset = l.texData.slice.flatOffset), { name: t.variableNames[f], shapeInfo: d };
+  }), i = o.map((l) => l.shapeInfo), a = {
+    logicalShape: r.shape,
+    texShape: r.texData.texShape,
+    isUniform: !1,
+    isPacked: r.texData.isPacked,
+    flatOffset: null
+  }, s = Le(o, a, t), c = Et(e.gl, s), u = e.createProgram(c);
+  return v().get("ENGINE_COMPILE_ONLY") ? {
+    program: t,
+    fragmentShader: c,
+    source: s,
+    webGLProgram: u,
+    inShapeInfos: i,
+    outShapeInfo: a,
+    variablesLocations: null,
+    customUniformLocations: null,
+    infLoc: null,
+    nanLoc: null,
+    outShapeLocation: null,
+    outShapeStridesLocation: null,
+    outTexShapeLocation: null
+  } : (e.buildVao(u), Object.assign({
+    program: t,
+    fragmentShader: c,
+    source: s,
+    webGLProgram: u,
+    inShapeInfos: i,
+    outShapeInfo: a
+  }, Nt(e, t, u)));
+}
+function Nt(e, t, n) {
+  const r = [], o = [];
+  let i, a, s, c = null, u = null;
+  u = e.getUniformLocation(n, "NAN", !1), v().getNumber("WEBGL_VERSION") === 1 && (c = e.getUniformLocation(n, "INFINITY", !1));
+  const l = !1;
+  for (const f of t.variableNames) {
+    const d = {
+      name: f,
+      uniform: e.getUniformLocation(n, f, l),
+      offset: e.getUniformLocation(n, `offset${f}`, l)
+    };
+    t.enableShapeUniforms && (d.shape = e.getUniformLocation(n, `${f}Shape`, l), d.texShape = e.getUniformLocation(n, `${f}TexShape`, l)), r.push(d);
+  }
+  if (t.enableShapeUniforms && (i = e.getUniformLocation(n, "outShape", l), s = e.getUniformLocation(n, "outShapeStrides", l), a = e.getUniformLocation(n, "outTexShape", l)), t.customUniforms)
+    for (const f of t.customUniforms)
+      o.push(e.getUniformLocation(n, f.name, l));
+  return {
+    variablesLocations: r,
+    customUniformLocations: o,
+    infLoc: c,
+    nanLoc: u,
+    outShapeLocation: i,
+    outShapeStridesLocation: s,
+    outTexShapeLocation: a
+  };
+}
+function re(e, t) {
+  if (e.length !== t.length)
+    throw Error(`Binary was compiled with ${e.length} inputs, but was executed with ${t.length} inputs`);
+  e.forEach((n, r) => {
+    const o = n.logicalShape, i = t[r], a = i.shape;
+    if (!T(o, a))
+      throw Error(`Binary was compiled with different shapes than the current args. Shapes ${o} and ${a} must match`);
+    if (n.isUniform && i.isUniform)
+      return;
+    const s = n.texShape, c = i.isUniform ? null : i.texData.texShape;
+    if (!T(s, c))
+      throw Error(`Binary was compiled with different texture shapes than the current args. Shape ${s} and ${c} must match`);
+  });
+}
+function Tn(e, t, n, r, o) {
+  t.program.enableShapeUniforms || (re(t.inShapeInfos, n), re([t.outShapeInfo], [r]));
+  const i = r.texData.texture, a = r.texData.texShape;
+  r.texData.isPacked ? e.setOutputPackedMatrixTexture(i.texture, a[0], a[1]) : e.setOutputMatrixTexture(i.texture, a[0], a[1]), e.setProgram(t.webGLProgram), e.bindVertexArray(t.webGLProgram.vao), v().getNumber("WEBGL_VERSION") === 1 && t.infLoc !== null && e.gl.uniform1f(t.infLoc, 1 / 0), t.nanLoc !== null && e.gl.uniform1f(t.nanLoc, NaN);
+  for (let c = 0; c < n.length; ++c) {
+    const u = n[c], { uniform: l, offset: f, shape: d, texShape: h } = t.variablesLocations[c];
+    if (d) {
+      const { uniformShape: x } = j(t.program.packedInputs, u.shape, u.texData.texShape);
+      switch (x.length) {
+        case 1:
+          e.gl.uniform1iv(d, new Int32Array(x));
+          break;
+        case 2:
+          e.gl.uniform2iv(d, new Int32Array(x));
+          break;
+        case 3:
+          e.gl.uniform3iv(d, new Int32Array(x));
+          break;
+        case 4:
+          e.gl.uniform4iv(d, new Int32Array(x));
+          break;
+      }
+    }
+    if (h && e.gl.uniform2i(h, u.texData.texShape[0], u.texData.texShape[1]), l != null) {
+      if (u.isUniform) {
+        if (E(u.shape) < 2)
+          e.gl.uniform1f(l, u.uniformValues[0]);
+        else {
+          let x = u.uniformValues;
+          x instanceof Float32Array || (x = new Float32Array(x)), e.gl.uniform1fv(l, x);
+        }
+        continue;
+      }
+      u.texData.slice != null && f != null && e.gl.uniform1i(f, u.texData.slice.flatOffset), e.setInputMatrixTexture(u.texData.texture.texture, l, c);
+    }
+  }
+  const s = t.outShapeLocation;
+  if (s)
+    switch (r.shape.length) {
+      case 1:
+        e.gl.uniform1iv(s, new Int32Array(r.shape));
+        break;
+      case 2:
+        e.gl.uniform2iv(s, new Int32Array(r.shape));
+        break;
+      case 3:
+        e.gl.uniform3iv(s, new Int32Array(r.shape));
+        break;
+      case 4:
+        e.gl.uniform4iv(s, new Int32Array(r.shape));
+        break;
+    }
+  if (t.outShapeStridesLocation) {
+    const c = B(r.shape);
+    switch (r.shape.length) {
+      case 2:
+        e.gl.uniform1iv(t.outShapeStridesLocation, new Int32Array(c));
+        break;
+      case 3:
+        e.gl.uniform2iv(t.outShapeStridesLocation, new Int32Array(c));
+        break;
+      case 4:
+        e.gl.uniform3iv(t.outShapeStridesLocation, new Int32Array(c));
+        break;
+    }
+  }
+  if (t.outTexShapeLocation && e.gl.uniform2i(t.outTexShapeLocation, r.texData.texShape[0], r.texData.texShape[1]), t.program.customUniforms && o)
+    for (let c = 0; c < t.program.customUniforms.length; ++c) {
+      const u = t.program.customUniforms[c], l = t.customUniformLocations[c], f = o[c];
+      if (u.type === "float")
+        e.gl.uniform1fv(l, f);
+      else if (u.type === "vec2")
+        e.gl.uniform2fv(l, f);
+      else if (u.type === "vec3")
+        e.gl.uniform3fv(l, f);
+      else if (u.type === "vec4")
+        e.gl.uniform4fv(l, f);
+      else if (u.type === "int")
+        e.gl.uniform1iv(l, f);
+      else if (u.type === "ivec2")
+        e.gl.uniform2iv(l, f);
+      else if (u.type === "ivec3")
+        e.gl.uniform3iv(l, f);
+      else if (u.type === "ivec4")
+        e.gl.uniform4iv(l, f);
+      else
+        throw Error(`uniform type ${u.type} is not supported yet.`);
+    }
+  e.executeProgram();
+}
+function Sn(e, t, n) {
+  let r = "";
+  t.concat(n).forEach((a) => {
+    const s = a.texData != null && a.texData.slice != null && a.texData.slice.flatOffset > 0;
+    if (e.enableShapeUniforms && !a.isUniform) {
+      const c = a.texData.texShape, { useSqueezeShape: u, uniformShape: l, keptDims: f } = j(e.packedInputs, a.shape, c);
+      let d = "", h = "", x = "";
+      if (l.length === 1 && e.packedInputs) {
+        const O = [Math.ceil(c[0] / 2), Math.ceil(c[1] / 2)];
+        d = `${O[0] > 1}_${O[1] > 1}`;
+      } else if (l.length === 2 && !e.packedInputs)
+        h = `${l[0] > 1}_${l[1] > 1}`;
+      else if (l.length > 2 && !e.packedInputs) {
+        const O = B(l);
+        x = `${O[0] === c[1]}_${O[O.length - 1] === c[1]}`;
+      }
+      const p = a.shape.length, $ = l.length === 2 && T(a.shape, c), S = E(a.shape) === 1, R = Te(a.shape, n.shape), w = !e.packedInputs && p === n.shape.length && T(c, n.texData.texShape), ve = e.packedInputs || l.length > 2 ? "" : `${c[0] > 1}_${c[1] > 1}`;
+      r += `${p}_${w}_${u ? f : ""}_${l.length}_${S}_${R}_${$}_${d}_${h}_${x}_${ve}_${s}`;
+    } else {
+      const c = a.isUniform ? "uniform" : a.texData.texShape;
+      r += `${a.shape}_${c}_${s}`;
+    }
+  });
+  const o = e.userCode;
+  let i = e.constructor.name;
+  return i += "_" + r + "_" + o + `${v().getNumber("WEBGL_VERSION")}`, i;
+}
+function Rn(e) {
+  return v().getBool("WEBGL_USE_SHAPES_UNIFORMS") && e <= 4;
+}
+export {
+  Tn as $,
+  mt as A,
+  kt as B,
+  Vt as C,
+  A as D,
+  yt as E,
+  Xt as F,
+  g as G,
+  Zt as H,
+  de as I,
+  on as J,
+  Gt as K,
+  zt as L,
+  qt as M,
+  en as N,
+  tn as O,
+  ee as P,
+  nn as Q,
+  an as R,
+  rn as S,
+  te as T,
+  Mt as U,
+  ne as V,
+  cn as W,
+  Pt as X,
+  Wt as Y,
+  Sn as Z,
+  $n as _,
+  bt as a,
+  sn as a0,
+  wt as a1,
+  Nt as a2,
+  mn as a3,
+  Lt as b,
+  V as c,
+  xe as d,
+  pe as e,
+  he as f,
+  Dt as g,
+  dn as h,
+  un as i,
+  ln as j,
+  fn as k,
+  hn as l,
+  xn as m,
+  pn as n,
+  vn as o,
+  L as p,
+  se as q,
+  jt as r,
+  Jt as s,
+  m as t,
+  Rn as u,
+  Bt as v,
+  Ht as w,
+  Qt as x,
+  Kt as y,
+  Yt as z
+};