@genai-fi/nanogpt 0.6.0 → 0.6.1

package/dist/gpgpu_math-B_ycgZ4W.js

@@ -0,0 +1,3115 @@
+import { ay as J, ac as m, az as le, aA as fe, aB as he, k as $, aC as we, aD as Q, i as T, W as D, aE as z, aF as Ce, aG as Fe, j as Ae, aH as de, au as _e, aI as Ie, u as Oe, aJ as Ne, aK as N, ai as E, aL as q, aM as ye, aN as ee } from "./index-CamYe_M8.js";
+import "./index-Tf7vU29b.js";
+import { b as Le, d as De, f as be, c as Ue, e as Me, g as Be, a as ke, h as Pe } from "./axis_util-CCNL7jea.js";
+import { S as We, a as Ve, b as He, c as Xe, d as Ge, e as ze, f as qe, g as je, h as Je, i as Ye, j as Ke, k as Ze, l as Qe, m as et, s as tt, n as nt, o as rt, t as ot } from "./selu_util-4QV_GXTB.js";
+import { c as at, v as st, a as it } from "./scatter_nd_util-qgtnviTE.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 ct = "model", ut = ".json", lt = ".weights.bin";
+function te(e) {
+  return new Promise((t) => setTimeout(t)).then(e);
+}
+class O {
+  constructor(t) {
+    if (!m().getBool("IS_BROWSER"))
+      throw new Error("browserDownloads() cannot proceed because the current environment is not a browser.");
+    t.startsWith(O.URL_SCHEME) && (t = t.slice(O.URL_SCHEME.length)), (t == null || t.length === 0) && (t = ct), this.modelJsonFileName = t + ut, this.weightDataFileName = t + lt;
+  }
+  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 = le.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
+      }], a = fe(t, o), s = window.URL.createObjectURL(new Blob([JSON.stringify(a)], { type: "application/json" })), i = this.modelJsonAnchor == null ? document.createElement("a") : this.modelJsonAnchor;
+      if (i.download = this.modelJsonFileName, i.href = s, await te(() => i.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 te(() => c.dispatchEvent(new MouseEvent("click")));
+      }
+      return { modelArtifactsInfo: he(t) };
+    }
+  }
+}
+O.URL_SCHEME = "downloads://";
+const ft = (e) => m().getBool("IS_BROWSER") && !Array.isArray(e) && e.startsWith(O.URL_SCHEME) ? ht(e.slice(O.URL_SCHEME.length)) : null;
+J.registerSaveRouter(ft);
+function ht(e = "model") {
+  return new O(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 ne(e, t, n, r) {
+  s(e), n = n ?? 0, r = r ?? 1, i(n, r);
+  let o = 0;
+  const a = (c) => (c.then((l) => {
+    const f = n + ++o / e.length * (r - n);
+    return t(f), l;
+  }), c);
+  function s(c) {
+    $(c != null && Array.isArray(c) && c.length > 0, () => "promises must be a none empty array");
+  }
+  function i(c, l) {
+    $(c >= 0 && c <= 1, () => `Progress fraction must be in range [0, 1], but got startFraction ${c}`), $(l >= 0 && l <= 1, () => `Progress fraction must be in range [0, 1], but got endFraction ${l}`), $(l >= c, () => `startFraction must be no more than endFraction, but got startFraction ${c} and endFraction ${l}`);
+  }
+  return Promise.all(e.map(a));
+}
+/**
+ * @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 dt(e, t) {
+  t == null && (t = {});
+  const n = t.fetchFunc == null ? m().platform.fetch : t.fetchFunc, r = e.map((u) => n(u, t.requestInit, { isBinary: !0 })), i = (t.onProgress == null ? await Promise.all(r) : await ne(r, t.onProgress, 0, 0.5)).map((u) => u.arrayBuffer());
+  return t.onProgress == null ? await Promise.all(i) : await ne(i, t.onProgress, 0.5, 1);
+}
+function pt(e, t) {
+  var n;
+  const r = t.fetchFunc == null ? m().platform.fetch : t.fetchFunc;
+  let o = 0, a;
+  return (n = t.onProgress) === null || n === void 0 || n.call(t, 0), new ReadableStream({
+    pull: async (s) => {
+      for (var i; o < e.length; ) {
+        a || (a = (await r(e[o], t.requestInit, { isBinary: !0 })).body.getReader());
+        const { done: c, value: l } = await a.read();
+        if (c) {
+          o++, a = void 0, (i = t.onProgress) === null || i === void 0 || i.call(t, o / e.length);
+          continue;
+        }
+        s.enqueue(l);
+        return;
+      }
+      s.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 xt = "application/octet-stream", mt = "application/json";
+class Y {
+  constructor(t, n) {
+    if (this.DEFAULT_METHOD = "POST", n == null && (n = {}), this.weightPathPrefix = n.weightPathPrefix, this.weightUrlConverter = n.weightUrlConverter, n.fetchFunc != null ? ($(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 = m().platform.fetch, $(t != null && t.length > 0, () => "URL path for http must not be null, undefined or empty."), Array.isArray(t) && $(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 = fe(t, r);
+    if (n.body.append("model.json", new Blob([JSON.stringify(o)], { type: mt }), "model.json"), t.weightData != null) {
+      const s = le.join(t.weightData);
+      n.body.append("model.weights.bin", new Blob([s], { type: xt }), "model.weights.bin");
+    }
+    const a = await this.fetch(this.path, n);
+    if (a.ok)
+      return {
+        modelArtifactsInfo: he(t),
+        responses: [a]
+      };
+    throw new Error(`BrowserHTTPRequest.save() failed due to HTTP response status ${a.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 s = `Failed to parse model JSON of response from ${this.path}.`;
+      throw this.path.endsWith(".pb") ? s += " 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." : s += " Please make sure the server is serving valid JSON for this request.", new Error(s);
+    }
+    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 we(t, (n) => this.loadWeights(n));
+  }
+  async loadStream() {
+    const t = await this.loadModelJSON(), n = await this.getWeightUrls(t.weightsManifest), r = Q(t.weightsManifest), o = () => pt(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] = vt(n), a = this.weightPathPrefix || r, s = [], i = [];
+    for (const c of t)
+      for (const l of c.paths)
+        this.weightUrlConverter != null ? i.push(this.weightUrlConverter(l)) : s.push(a + l + o);
+    return this.weightUrlConverter && s.push(...await Promise.all(i)), s;
+  }
+  async loadWeights(t) {
+    const n = await this.getWeightUrls(t), r = Q(t), o = await dt(n, this.loadOptions);
+    return [r, o];
+  }
+}
+Y.URL_SCHEME_REGEX = /^https?:\/\//;
+function vt(e) {
+  const t = e.lastIndexOf("/"), n = e.lastIndexOf("?"), r = e.substring(0, t), o = n > t ? e.substring(n) : "";
+  return [r + "/", o];
+}
+function re(e) {
+  return e.match(Y.URL_SCHEME_REGEX) != null;
+}
+const pe = (e, t) => {
+  if (typeof fetch > "u" && (t == null || t.fetchFunc == null))
+    return null;
+  {
+    let n = !0;
+    if (Array.isArray(e) ? n = e.every((r) => re(r)) : n = re(e), n)
+      return $t(e, t);
+  }
+  return null;
+};
+J.registerSaveRouter(pe);
+J.registerLoadRouter(pe);
+function $t(e, t) {
+  return new Y(e, t);
+}
+function Tt(e, t) {
+  const n = e.shape.length, r = t.shape.length;
+  if (n < 1)
+    throw new Error(`tf.gatherND() expects the input to be rank 1 or higher, but the rank was ${n}.`);
+  if (r < 1)
+    throw new Error(`tf.gatherND() expects the indices to be rank 1 or higher, but the rank was ${r}.`);
+  if (t.dtype !== "int32")
+    throw new Error(`tf.gatherND() expects the indices to be int32 type, but the dtype was ${t.dtype}.`);
+  if (t.shape[r - 1] > n)
+    throw new Error(`index innermost dimension length must be <= tensor rank; saw: ${t.shape[r - 1]} vs. ${n}`);
+  if (T(e.shape) === 0)
+    throw new Error(`Requested more than 0 entries, but input is empty. Input shape: ${e.shape}.`);
+  const o = t.shape, a = o[o.length - 1];
+  let s = 1;
+  for (let u = 0; u < o.length - 1; ++u)
+    s *= o[u];
+  const i = e.shape, c = o.slice();
+  c.pop();
+  let l = 1;
+  for (let u = a; u < n; ++u)
+    l *= i[u], c.push(i[u]);
+  const f = [
+    ...D(e.shape).map((u) => u / l),
+    1
+  ].slice(0, a);
+  return [c, s, l, f];
+}
+/**
+ * @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 St(e, t) {
+  const n = e[0].length;
+  e.forEach((o, a) => {
+    $(o.length === n, () => `Error in concat${n}D: rank of tensors[${a}] must be the same as the rank of the rest (${n})`);
+  }), $(t >= 0 && t < n, () => `Error in concat${n}D: axis must be between 0 and ${n - 1}.`);
+  const r = e[0];
+  e.forEach((o, a) => {
+    for (let s = 0; s < n; s++)
+      $(s === t || o[s] === r[s], () => `Error in concat${n}D: Shape of tensors[${a}] (${o}) does not match the shape of the rest (${r}) along the non-concatenated axis ${a}.`);
+  });
+}
+function Et(e, t) {
+  const n = e[0].slice();
+  for (let r = 1; r < e.length; r++)
+    n[t] += e[r][t];
+  return n;
+}
+/**
+ * @license
+ * Copyright 2022 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 R;
+(function(e) {
+  e[e.FIRST_DIM_SIZE = 0] = "FIRST_DIM_SIZE", e[e.VALUE_ROWIDS = 1] = "VALUE_ROWIDS", e[e.ROW_LENGTHS = 2] = "ROW_LENGTHS", e[e.ROW_SPLITS = 3] = "ROW_SPLITS", e[e.ROW_LIMITS = 4] = "ROW_LIMITS", e[e.ROW_STARTS = 5] = "ROW_STARTS";
+})(R || (R = {}));
+function Rt(e, t, n) {
+  let r = new Array();
+  if (n == null && t == null)
+    return r;
+  if (t == null)
+    for (; r.length < e + n.length; )
+      r.push(-1);
+  else
+    r = t.slice();
+  if (n == null)
+    return r;
+  if (e + n.length !== r.length)
+    throw new Error(`rt input.shape and shape=${t} are incompatible: rt input.rank = ${e + n.length}, but shape.rank = ${r.length}`);
+  for (let o = 1; o < n.length; ++o) {
+    const a = n[o], s = r[r.length - n.length + o], i = r[s];
+    if (a >= 0)
+      if (i >= 0) {
+        if (i !== a)
+          throw new Error(`rt input.shape and shape=${t} are incompatible: rt input.shape[${o + e}] = ${a} but shape[${o + e}] = ${i}`);
+      } else
+        r[s] = a;
+  }
+  return r;
+}
+function gt(e) {
+  const t = {
+    FIRST_DIM_SIZE: R.FIRST_DIM_SIZE,
+    VALUE_ROWIDS: R.VALUE_ROWIDS,
+    ROW_LENGTHS: R.ROW_LENGTHS,
+    ROW_SPLITS: R.ROW_SPLITS,
+    ROW_LIMITS: R.ROW_LIMITS,
+    ROW_STARTS: R.ROW_STARTS
+  }, n = [];
+  for (const r of e)
+    if (r in t)
+      n.push(t[r]);
+    else
+      break;
+  return n;
+}
+function wt(e) {
+  return e.length === 0 ? 0 : e[0] === R.FIRST_DIM_SIZE ? e.length - 1 : e.length;
+}
+function Ct(e, t) {
+  if (e == null || t == null)
+    return;
+  const n = e.length, r = t.length;
+  if (n >= r)
+    throw new Error(`defaultValue.shape=${e} and ragged tensor flatValues.shape=${t}, are incompatible: defaultValue.rank = ${n} must be less than ragged tensor input flatValues.rank = ${r})`);
+  for (let o = 0; o < Math.min(n, r - 1); ++o) {
+    const a = e[o], s = t[o + 1];
+    if (a >= 0 && s >= 0 && a !== 1 && a !== s)
+      throw new Error(`defaultValue.shape=${e}, and ragged tensor input flatValues.shape=${t} are incompatible: defaultValue.shape[${o - e.length}] = ${a} but ragged tensor input.flatValues.shape[${o - e.length}] = ${s}`);
+  }
+}
+/**
+ * @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 K = 30;
+function Ft(e) {
+  return e <= K ? e : z(e, Math.floor(Math.sqrt(e)));
+}
+/**
+ * @license
+ * Copyright 2020 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 At(e, t, n) {
+  const r = n * (typeof e == "number" ? e : e[0]), o = t * (typeof e == "number" ? e : e[1]);
+  return [r, o];
+}
+/**
+ * @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 _t(e, t, n, r = !0) {
+  let o = [];
+  if (r)
+    o = o.concat(t.slice(0)), o.push(e[0] / n), o = o.concat(e.slice(1));
+  else {
+    o = o.concat(e[0]);
+    const a = t.length;
+    for (let s = 0; s < a; ++s)
+      o = o.concat([e[s + 1] / t[s], t[s]]);
+    o = o.concat(e.slice(a + 1));
+  }
+  return o;
+}
+function It(e, t, n = !0) {
+  const r = [];
+  if (n) {
+    r.push(t);
+    for (let o = t + 1; o < e; ++o)
+      o <= 2 * t ? (r.push(o), r.push(o - (t + 1))) : r.push(o);
+  } else {
+    const o = [], a = [];
+    for (let s = 1; s < e; ++s)
+      s >= t * 2 + 1 || s % 2 === 1 ? a.push(s) : o.push(s);
+    r.push(...o), r.push(0), r.push(...a);
+  }
+  return r;
+}
+function Ot(e, t, n, r = !0) {
+  const o = [];
+  r ? o.push(e[0] / n) : o.push(e[0] * n);
+  for (let a = 1; a < e.length; ++a)
+    a <= t.length ? r ? o.push(t[a - 1] * e[a]) : o.push(e[a] / t[a - 1]) : o.push(e[a]);
+  return o;
+}
+function Nt(e, t) {
+  const n = [0];
+  for (let r = 0; r < t; ++r)
+    n.push(e[r][0]);
+  return n;
+}
+function yt(e, t, n) {
+  const r = e.slice(0, 1);
+  for (let o = 0; o < n; ++o)
+    r.push(e[o + 1] - t[o][0] - t[o][1]);
+  return r;
+}
+/**
+ * @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 Lt = 0.3275911, Dt = 0.254829592, bt = -0.284496736, Ut = 1.421413741, Mt = -1.453152027, Bt = 1.061405429;
+/**
+ * @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 kt(e, t) {
+  if (e.length !== t.length)
+    throw new Error(`Cannot merge real and imag arrays of different lengths. real:${e.length}, imag: ${t.length}.`);
+  const n = new Float32Array(e.length * 2);
+  for (let r = 0; r < n.length; r += 2)
+    n[r] = e[r / 2], n[r + 1] = t[r / 2];
+  return n;
+}
+function Pt(e) {
+  const t = new Float32Array(e.length / 2), n = new Float32Array(e.length / 2);
+  for (let r = 0; r < e.length; r += 2)
+    t[r / 2] = e[r], n[r / 2] = e[r + 1];
+  return { real: t, imag: n };
+}
+function Wt(e) {
+  const t = Math.ceil(e.length / 4), n = new Float32Array(t), r = new Float32Array(t);
+  for (let o = 0; o < e.length; o += 4)
+    n[Math.floor(o / 4)] = e[o], r[Math.floor(o / 4)] = e[o + 1];
+  return { real: n, imag: r };
+}
+function Vt(e) {
+  const t = Math.floor(e.length / 4), n = new Float32Array(t), r = new Float32Array(t);
+  for (let o = 2; o < e.length; o += 4)
+    n[Math.floor(o / 4)] = e[o], r[Math.floor(o / 4)] = e[o + 1];
+  return { real: n, imag: r };
+}
+function Ht(e, t) {
+  const n = e[t * 2], r = e[t * 2 + 1];
+  return { real: n, imag: r };
+}
+function Xt(e, t, n, r) {
+  e[r * 2] = t, e[r * 2 + 1] = n;
+}
+function Gt(e, t) {
+  const n = new Float32Array(e / 2), r = new Float32Array(e / 2);
+  for (let o = 0; o < Math.ceil(e / 2); o++) {
+    const a = (t ? 2 : -2) * Math.PI * (o / e);
+    n[o] = Math.cos(a), r[o] = Math.sin(a);
+  }
+  return { real: n, imag: r };
+}
+function zt(e, t, n) {
+  const r = (n ? 2 : -2) * Math.PI * (e / t), o = Math.cos(r), a = Math.sin(r);
+  return { real: o, imag: a };
+}
+/**
+ * @license
+ * Copyright 2021 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 H = "->", qt = /->/g, oe = ",", ae = "...";
+function jt(e, t) {
+  e = e.replace(/\s/g, "");
+  const n = (e.length - e.replace(qt, "").length) / H.length;
+  if (n < 1)
+    throw new Error("Equations without an arrow are not supported.");
+  if (n > 1)
+    throw new Error(`Equation must contain exactly one arrow ("${H}").`);
+  const [r, o] = e.split(H);
+  $(r.indexOf(ae) === -1, () => `The ellipsis notation ("${ae}") is not supported yet.`);
+  const a = r.split(oe), s = a.length;
+  if (t !== s)
+    throw new Error(`Expected ${s} input tensors, received ${t}`);
+  if (s > 2)
+    throw new Error("Support for more than 2 input tensors is not implemented yet.");
+  const i = [];
+  for (let h = 0; h < o.length; ++h) {
+    const d = o[h];
+    if (!a.some((p) => p.indexOf(d) !== -1))
+      throw new Error(`Output subscripts contain the label ${d} not present in the input subscripts.`);
+    i.indexOf(d) === -1 && i.push(d);
+  }
+  for (let h = 0; h < r.length; ++h) {
+    const d = r[h];
+    i.indexOf(d) === -1 && d !== oe && i.push(d);
+  }
+  const c = new Array(a.length);
+  for (let h = 0; h < s; ++h) {
+    if (new Set(a[h].split("")).size !== a[h].length)
+      throw new Error(`Found duplicate axes in input component ${a[h]}. Support for duplicate axes in input is not implemented yet.`);
+    c[h] = [];
+    for (let d = 0; d < a[h].length; ++d)
+      c[h].push(i.indexOf(a[h][d]));
+  }
+  const l = i.length, f = o.length, u = [];
+  for (let h = f; h < l; ++h)
+    u.push(h);
+  return { allDims: i, summedDims: u, idDims: c };
+}
+function Jt(e, t) {
+  let n = new Array(e);
+  n.fill(-1);
+  for (let o = 0; o < t.length; ++o)
+    n[t[o]] = o;
+  const r = [];
+  for (let o = 0; o < e; ++o)
+    n[o] === -1 && r.push(o);
+  return n = n.filter((o) => o !== -1), { permutationIndices: n, expandDims: r };
+}
+function Yt(e, t, n) {
+  const r = new Array(e);
+  for (let o = 0; o < n.length; ++o) {
+    const a = n[o].shape;
+    for (let s = 0; s < t[o].length; ++s)
+      r[t[o][s]] === void 0 ? r[t[o][s]] = a[s] : $(r[t[o][s]] === a[s], () => `Expected dimension ${r[t[o][s]]} at axis ${s} of input shaped ${JSON.stringify(a)}, but got dimension ${a[s]}`);
+  }
+}
+function Kt(e, t) {
+  const n = e, r = [];
+  let o = 0;
+  e.length === 0 && n.push(-1), o = e.length + 1;
+  for (let s = 0; s < o; ++s)
+    r.push([]);
+  const a = [];
+  for (let s = 0; s < n.length; ++s) {
+    const i = n[s], c = Qt(t, i);
+    for (const l of c)
+      a.indexOf(l) === -1 && (r[s].push(l), a.push(l));
+  }
+  return { path: n, steps: r };
+}
+function Zt(e) {
+  return e.every((t, n) => t === n);
+}
+function Qt(e, t) {
+  const n = [];
+  for (let r = 0; r < e.length; ++r)
+    (e[r].length === 0 || e[r].indexOf(t) !== -1 || t === -1) && n.push(r);
+  return n;
+}
+function en(e, t, n = 0) {
+  let r = [];
+  if (typeof t == "number")
+    $(e.shape[n] % t === 0, () => "Number of splits must evenly divide the axis."), r = new Array(t).fill(e.shape[n] / t);
+  else {
+    const o = t.reduce((s, i) => (i === -1 && (s += 1), s), 0);
+    $(o <= 1, () => "There should be only one negative value in split array.");
+    const a = t.indexOf(-1);
+    if (a !== -1) {
+      const s = t.reduce((i, c) => c > 0 ? i + c : i);
+      t[a] = e.shape[n] - s;
+    }
+    $(e.shape[n] === t.reduce((s, i) => s + i), () => "The sum of sizes must match the size of the axis dimension."), r = t;
+  }
+  return r;
+}
+/**
+ * @license
+ * Copyright 2021 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 tn(e) {
+  return `Received SparseTensor with denseShape[0] = 0 but
+  indices.shape[0] = ${e}`;
+}
+function nn(e, t) {
+  return `indices(${e}, 0) is invalid: ${t} < 0`;
+}
+function rn(e, t, n) {
+  return `indices(${e}, 0) is invalid: ${t} >= ${n}`;
+}
+/**
+ * @license
+ * Copyright 2021 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 on(e, t) {
+  return `only one output dimension may be -1, not both ${e} and ${t}`;
+}
+function an(e, t) {
+  return `size ${e} must be non-negative, not ${t}`;
+}
+function sn() {
+  return "reshape cannot infer the missing input size for an empty tensor unless all specified input sizes are non-zero";
+}
+function cn(e, t) {
+  const n = T(e), r = T(t);
+  return `Input to reshape is a SparseTensor with ${n}
+  dense values, but the requested shape requires a multiple of ${r}. inputShape=${e} outputShape= ${t}`;
+}
+function un(e, t) {
+  const n = T(e), r = T(t);
+  return `Input to reshape is a tensor with ${n} dense values, but the requested shape has ${r}. inputShape=${e} outputShape=${t}`;
+}
+/**
+ * @license
+ * Copyright 2021 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 ln() {
+  return "segment ids must be >= 0";
+}
+function fn() {
+  return "segment ids are not increasing";
+}
+function hn(e, t) {
+  return `Segment id ${e} out of range [0, ${t}), possibly because segmentIds input is not sorted.`;
+}
+function dn(e, t, n) {
+  return `Bad: indices[${e}] == ${t} out of range [0, ${n})`;
+}
+/**
+ * @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 pn(e, t) {
+  let n = !1, r;
+  for (e <= K ? (r = e, n = !0) : r = z(e, Math.floor(Math.sqrt(e))); !n; )
+    r > t || r === e ? n = !0 : r = z(e, r + 1);
+  return r;
+}
+function xn(e, t, n) {
+  const r = [], o = e.length;
+  for (let a = 0; a < o; a++)
+    a !== t ? r.push(e[a]) : r.push(n);
+  return r;
+}
+function mn(e, t, n, r) {
+  const o = t.shape.length, a = e.shape.length;
+  if (r !== 0 && (r < -o || r > o))
+    throw new Error(`Expect batchDims in the range of [-${o}, ${o}], but got ${r}`);
+  if (r < 0 && (r += o), r > a)
+    throw new Error(`batchDims (${r}) must be less than rank(x) (
+    ${a}).`);
+  if (n < r)
+    throw new Error(`batchDims (${r}) must be less than or equal to axis (${n}).`);
+  for (let u = 0; u < r; ++u)
+    if (e.shape[u] !== t.shape[u])
+      throw new Error(`x.shape[${u}]: ${e.shape[u]} should be equal to indices.shape[${u}]: ${t.shape[u]}.`);
+  const s = e.shape[n], i = [];
+  let c = 1, l = 1, f = 1;
+  for (let u = 0; u < r; ++u)
+    i.push(e.shape[u]), c *= e.shape[u];
+  for (let u = r; u < n; u++)
+    i.push(e.shape[u]), l *= e.shape[u];
+  for (let u = r; u < o; u++)
+    i.push(t.shape[u]);
+  for (let u = n + 1; u < a; u++)
+    i.push(e.shape[u]), f *= e.shape[u];
+  return { batchSize: c, sliceSize: f, outerSize: l, dimSize: s, outputShape: i };
+}
+const vn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  collectGatherOpShapeInfo: mn,
+  computeOutShape: xn,
+  segOpComputeOptimalWindowSize: pn
+}, Symbol.toStringTag, { value: "Module" }));
+/**
+ * @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 $n(e) {
+  try {
+    return e.map((t) => Ce(t));
+  } catch (t) {
+    throw new Error(`Failed to decode encoded string bytes into utf-8, error: ${t}`);
+  }
+}
+function Tn(e) {
+  return e.map((t) => Fe(t));
+}
+const Sn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ERF_A1: Dt,
+  ERF_A2: bt,
+  ERF_A3: Ut,
+  ERF_A4: Mt,
+  ERF_A5: Bt,
+  ERF_P: Lt,
+  PARALLELIZE_THRESHOLD: K,
+  get RowPartitionType() {
+    return R;
+  },
+  SELU_SCALE: We,
+  SELU_SCALEALPHA: Ve,
+  applyActivation: He,
+  assertAndGetBroadcastShape: Ae,
+  assertAxesAreInnerMostDims: Le,
+  assertParamsConsistent: St,
+  assignToTypedArray: Xt,
+  axesAreInnerMostDims: De,
+  calculateShapes: at,
+  checkEinsumDimSizes: Yt,
+  checkPadOnDimRoundingMode: Xe,
+  combineLocations: be,
+  combineRaggedTensorToTensorShapes: Rt,
+  complexWithEvenIndex: Wt,
+  complexWithOddIndex: Vt,
+  computeConv2DInfo: Ge,
+  computeConv3DInfo: ze,
+  computeDefaultPad: qe,
+  computeDilation2DInfo: je,
+  computeOptimalWindowSize: Ft,
+  computeOutAndReduceShapes: Ue,
+  computeOutShape: Et,
+  computePool2DInfo: Je,
+  computePool3DInfo: Ye,
+  convertConv2DDataFormat: Ke,
+  decodeEinsumEquation: jt,
+  eitherStridesOrDilationsAreOne: Ze,
+  expandShapeToKeepDim: Me,
+  exponent: zt,
+  exponents: Gt,
+  fromStringArrayToUint8: Tn,
+  fromUint8ToStringArray: $n,
+  getAxesPermutation: Be,
+  getBroadcastDims: de,
+  getComplexWithIndex: Ht,
+  getEinsumComputePath: Kt,
+  getEinsumPermutation: Jt,
+  getFusedBiasGradient: Qe,
+  getFusedDyActivation: et,
+  getImageCenter: At,
+  getInnerMostAxes: ke,
+  getPermuted: It,
+  getRaggedRank: wt,
+  getReductionAxes: _e,
+  getReshaped: _t,
+  getReshapedPermuted: Ot,
+  getRowPartitionTypesHelper: gt,
+  getSliceBeginCoords: Nt,
+  getSliceSize: yt,
+  getSparseFillEmptyRowsIndicesDenseShapeMismatch: tn,
+  getSparseFillEmptyRowsNegativeIndexErrorMessage: nn,
+  getSparseFillEmptyRowsOutOfRangeIndexErrorMessage: rn,
+  getSparseReshapeEmptyTensorZeroOutputDimErrorMessage: sn,
+  getSparseReshapeInputOutputMismatchErrorMessage: un,
+  getSparseReshapeInputOutputMultipleErrorMessage: cn,
+  getSparseReshapeMultipleNegativeOneOutputDimErrorMessage: on,
+  getSparseReshapeNegativeOutputDimErrorMessage: an,
+  getSparseSegmentReductionIndicesOutOfRangeErrorMessage: dn,
+  getSparseSegmentReductionNegativeSegmentIdsErrorMessage: ln,
+  getSparseSegmentReductionNonIncreasingSegmentIdsErrorMessage: fn,
+  getSparseSegmentReductionSegmentIdOutOfRangeErrorMessage: hn,
+  getUndoAxesPermutation: Pe,
+  isIdentityPermutation: Zt,
+  log: Ie,
+  mergeRealAndImagArrays: kt,
+  prepareAndValidate: Tt,
+  prepareSplitSize: en,
+  segment_util: vn,
+  shouldFuse: tt,
+  slice_util: nt,
+  splitRealAndImagArrays: Pt,
+  stridesOrDilationsArePositive: rt,
+  tupleValuesAreOne: ot,
+  upcastType: Oe,
+  validateDefaultValueShape: Ct,
+  validateInput: st,
+  validateUpdateShape: it,
+  warn: Ne
+}, Symbol.toStringTag, { value: "Module" }));
+/**
+ * @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 b() {
+  let e, t, n, r, o, a, s, i, c, l;
+  return m().getNumber("WEBGL_VERSION") === 2 ? (e = "#version 300 es", t = "in", n = "out", r = "in", o = "texture", a = "outputColor", s = "out vec4 outputColor;", i = m().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 = "", l = `
+      #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", a = "gl_FragColor", s = "", i = `
+      #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));
+      }
+    `, l = `
+      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: a,
+    defineOutput: s,
+    defineSpecialNaN: i,
+    defineSpecialInf: c,
+    defineRound: l
+  };
+}
+/**
+ * @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 = D(t);
+  return r.map((o, a) => {
+    const s = `int ${e[a]} = ${n} / ${o}`, i = a === r.length - 1 ? `int ${e[a + 1]} = ${n} - ${e[a]} * ${o}` : `index -= ${e[a]} * ${o}`;
+    return `${s}; ${i};`;
+  }).join("");
+}
+function xe(e, t, n = "index") {
+  const r = D(t);
+  return r.map((o, a) => {
+    const s = `int ${e[a]} = ${n} / outShapeStrides[${a}]`, i = a === r.length - 1 ? `int ${e[a + 1]} = ${n} - ${e[a]} * outShapeStrides[${a}]` : `index -= ${e[a]} * outShapeStrides[${a}]`;
+    return `${s}; ${i};`;
+  }).join("");
+}
+function En(e, t) {
+  const n = e.length, r = e.map((a) => `${t}[${a}]`), o = new Array(n - 1);
+  o[n - 2] = r[n - 1];
+  for (let a = n - 3; a >= 0; --a)
+    o[a] = `(${o[a + 1]} * ${r[a + 1]})`;
+  return o;
+}
+function wr(e, t, n = "index") {
+  const r = e.map((a, s) => s), o = En(r, t);
+  return o.map((a, s) => {
+    const i = `int ${e[s]} = ${n} / ${o[s]}`, c = s === o.length - 1 ? `int ${e[s + 1]} = ${n} - ${e[s]} * ${o[s]}` : `index -= ${e[s]} * ${o[s]}`;
+    return `${i}; ${c};`;
+  }).join("");
+}
+function Cr(e) {
+  const t = D(e).map((n) => n.toString());
+  return `
+  int getFlatIndex(ivec3 coords) {
+    return coords.x * ${t[0]} + coords.y * ${t[1]} + coords.z;
+  }
+`;
+}
+function Fr() {
+  return `
+  int getFlatIndex(ivec3 coords) {
+    return coords.x * outShapeStrides[0] + coords.y * outShapeStrides[1] + coords.z;
+  }
+`;
+}
+const Ar = `
+  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: me } = Sn;
+function Rn(e, t, n) {
+  const r = [];
+  if (e.forEach((d) => {
+    const p = T(d.shapeInfo.logicalShape);
+    if (d.shapeInfo.isUniform ? r.push(`uniform float ${d.name}${p > 1 ? `[${p}]` : ""};`) : (r.push(`uniform sampler2D ${d.name};`), r.push(`uniform int offset${d.name};`)), n.enableShapeUniforms) {
+      const { uniformShape: x } = Z(n.packedInputs, d.shapeInfo.logicalShape, d.shapeInfo.texShape);
+      switch (x.length) {
+        case 1:
+          r.push(`uniform int ${d.name}Shape;`);
+          break;
+        case 2:
+          r.push(`uniform ivec2 ${d.name}Shape;`);
+          break;
+        case 3:
+          r.push(`uniform ivec3 ${d.name}Shape;`);
+          break;
+        case 4:
+          r.push(`uniform ivec4 ${d.name}Shape;`);
+          break;
+      }
+      r.push(`uniform ivec2 ${d.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((d) => {
+    r.push(`uniform ${d.type} ${d.name}${d.arrayIndex ? `[${d.arrayIndex}]` : ""};`);
+  });
+  const o = r.join(`
+`), a = e.map((d) => gn(d, t, n.packedInputs, n.enableShapeUniforms)).join(`
+`), s = t.texShape, i = b(), c = Fn(i);
+  let l, f, u = In(i);
+  return t.isPacked ? (l = wn(t.logicalShape, s, n.enableShapeUniforms), f = _n(i)) : (l = Cn(t.logicalShape, s, n.enableShapeUniforms), f = An(i)), n.packedInputs && (u += Ln), [
+    u,
+    c,
+    f,
+    o,
+    l,
+    a,
+    n.userCode
+  ].join(`
+`);
+}
+function U(e, t = !1) {
+  const n = e.shapeInfo.logicalShape;
+  switch (n.length) {
+    case 0:
+      return Gn(e, t);
+    case 1:
+      return qn(e, t);
+    case 2:
+      return Jn(e, t);
+    case 3:
+      return Kn(e, t);
+    case 4:
+      return Qn(e, t);
+    case 5:
+      return er(e);
+    case 6:
+      return tr(e);
+    default:
+      throw new Error(`${n.length}-D input sampling is not yet supported`);
+  }
+}
+function ve(e, t) {
+  switch (e.shapeInfo.logicalShape.length) {
+    case 0:
+      return Xn(e);
+    case 1:
+      return zn(e, t);
+    case 2:
+      return jn(e, t);
+    case 3:
+      return Yn(e, t);
+    default:
+      return Zn(e, t);
+  }
+}
+function gn(e, t, n = !1, r) {
+  let o = "";
+  n ? o += ve(e, r) : o += U(e, r);
+  const a = e.shapeInfo.logicalShape, s = t.logicalShape;
+  return a.length <= s.length && (n ? o += nr(e, t) : o += rr(e, t)), o;
+}
+function wn(e, t, n) {
+  switch (e.length) {
+    case 0:
+      return $e();
+    case 1:
+      return Dn(e, t, n);
+    case 2:
+      return Vn(e, t, n);
+    case 3:
+      return Un(e, t, n);
+    default:
+      return Bn(e, t, n);
+  }
+}
+function Cn(e, t, n) {
+  switch (e.length) {
+    case 0:
+      return $e();
+    case 1:
+      return bn(e, t, n);
+    case 2:
+      return Hn(e, t, n);
+    case 3:
+      return Mn(e, t, n);
+    case 4:
+      return kn(e, t, n);
+    case 5:
+      return Pn(e, t);
+    case 6:
+      return Wn(e, t);
+    default:
+      throw new Error(`${e.length}-D output sampling is not yet supported`);
+  }
+}
+function Fn(e) {
+  return `
+    float sampleTexture(sampler2D textureSampler, vec2 uv) {
+      return ${e.texture2D}(textureSampler, uv).r;
+    }
+  `;
+}
+function An(e) {
+  return `
+    void setOutput(float val) {
+      ${e.output} = vec4(val, 0, 0, 0);
+    }
+  `;
+}
+function _n(e) {
+  return `
+    void setOutput(vec4 val) {
+      ${e.output} = val;
+    }
+  `;
+}
+function In(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);
+    }
+
+    ${On}
+    ${Nn}
+    ${yn}
+  `;
+}
+const On = `
+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);
+}
+`, Nn = `
+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);
+}
+`, yn = `
+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);
+}
+`, Ln = `
+  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 $e() {
+  return `
+    int getOutputCoords() {
+      return 0;
+    }
+  `;
+}
+function Dn(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 bn(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 Un(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), a = 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 / ${a};
+      index -= b * ${a};
+
+      int r = 2 * (index / ${o});
+      int c = imod(index, ${o}) * 2;
+
+      return ivec3(b, r, c);
+    }
+  `;
+}
+function Mn(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;
+    ${xe(["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 Bn(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), a = o * Math.ceil(e[e.length - 2] / 2);
+  let s = a, i = "", c = "b, r, c";
+  for (let l = 2; l < e.length - 1; l++)
+    s *= e[e.length - l - 1], i = `
+      int b${l} = index / ${s};
+      index -= b${l} * ${s};
+    ` + i, c = `b${l}, ` + c;
+  return `
+    ivec${e.length} getOutputCoords() {
+      ivec2 resTexRC = ivec2(resultUV.yx *
+                             vec2(${r[0]}, ${r[1]}));
+      int index = resTexRC.x * ${r[1]} + resTexRC.y;
+
+      ${i}
+
+      int b = index / ${a};
+      index -= b * ${a};
+
+      int r = 2 * (index / ${o});
+      int c = imod(index, ${o}) * 2;
+
+      return ivec${e.length}(${c});
+    }
+  `;
+}
+function kn(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;
+      ${xe(["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 Pn(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 Wn(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 Vn(e, t, n) {
+  const r = [Math.ceil(t[0] / 2), Math.ceil(t[1] / 2)];
+  if (E(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 Hn(e, t, n) {
+  return E(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 y(e) {
+  return `offset${e}`;
+}
+function Xn(e) {
+  const t = e.name, n = "get" + t.charAt(0).toUpperCase() + t.slice(1), r = b();
+  return `
+    vec4 ${n}() {
+      return ${r.texture2D}(${t}, halfCR);
+    }
+  `;
+}
+function Gn(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, a] = e.shapeInfo.texShape;
+  if (o === 1 && a === 1)
+    return `
+      float ${r}() {
+        return sampleTexture(${n}, halfCR);
+      }
+    `;
+  const s = y(n);
+  if (t)
+    return `
+    float ${r}() {
+      vec2 uv = uvFromFlat(${n}TexShape[0], ${n}TexShape[1], ${s});
+      return sampleTexture(${n}, uv);
+    }
+  `;
+  const [i, c] = e.shapeInfo.texShape;
+  return `
+    float ${r}() {
+      vec2 uv = uvFromFlat(${i}, ${c}, ${s});
+      return sampleTexture(${n}, uv);
+    }
+  `;
+}
+function zn(e, t) {
+  const n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1), o = e.shapeInfo.texShape, a = b();
+  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 ${a.texture2D}(${n}, uv);
+    }
+  `;
+  const s = [Math.ceil(o[0] / 2), Math.ceil(o[1] / 2)];
+  return `
+    vec4 ${r}(int index) {
+      vec2 uv = packedUVfrom1D(
+        ${s[0]}, ${s[1]}, index);
+      return ${a.texture2D}(${n}, uv);
+    }
+  `;
+}
+function qn(e, t) {
+  const n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1);
+  if (e.shapeInfo.isUniform)
+    return `
+      float ${r}(int index) {
+        ${M(e)}
+      }
+    `;
+  const o = e.shapeInfo.texShape, a = o[0], s = o[1];
+  if (s === 1 && a === 1)
+    return `
+      float ${r}(int index) {
+        return sampleTexture(${n}, halfCR);
+      }
+    `;
+  const i = y(n);
+  return s === 1 ? t ? `
+      float ${r}(int index) {
+        vec2 uv = vec2(0.5, (float(index + ${i}) + 0.5) / float(${n}TexShape[0]));
+        return sampleTexture(${n}, uv);
+      }
+    ` : `
+      float ${r}(int index) {
+        vec2 uv = vec2(0.5, (float(index + ${i}) + 0.5) / ${a}.0);
+        return sampleTexture(${n}, uv);
+      }
+    ` : a === 1 ? t ? `
+      float ${r}(int index) {
+        vec2 uv = vec2((float(index + ${i}) + 0.5) / float(${n}TexShape[1]), 0.5);
+        return sampleTexture(${n}, uv);
+      }
+    ` : `
+      float ${r}(int index) {
+        vec2 uv = vec2((float(index + ${i}) + 0.5) / ${s}.0, 0.5);
+        return sampleTexture(${n}, uv);
+      }
+    ` : t ? `
+    float ${r}(int index) {
+      vec2 uv = uvFromFlat(${n}TexShape[0], ${n}TexShape[1], index + ${i});
+      return sampleTexture(${n}, uv);
+    }
+  ` : `
+    float ${r}(int index) {
+      vec2 uv = uvFromFlat(${a}, ${s}, index + ${i});
+      return sampleTexture(${n}, uv);
+    }
+  `;
+}
+function jn(e, t) {
+  const n = e.shapeInfo.logicalShape, r = e.name, o = "get" + r.charAt(0).toUpperCase() + r.slice(1), a = e.shapeInfo.texShape, s = a[0], i = a[1], c = b();
+  if (a != null && E(n, a))
+    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(${i}.0, ${s}.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 l = [Math.ceil(a[0] / 2), Math.ceil(a[1] / 2)], f = Math.ceil(n[1] / 2);
+  return `
+    vec4 ${o}(int row, int col) {
+      vec2 uv = packedUVfrom2D(${f}, ${l[0]}, ${l[1]}, row, col);
+      return ${c.texture2D}(${r}, uv);
+    }
+  `;
+}
+function Jn(e, t) {
+  const n = e.shapeInfo.logicalShape, r = e.name, o = "get" + r.charAt(0).toUpperCase() + r.slice(1), a = e.shapeInfo.texShape;
+  if (a != null && E(n, a)) {
+    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 h = a[0], d = a[1];
+    return `
+    float ${o}(int row, int col) {
+      vec2 uv = (vec2(col, row) + halfCR) / vec2(${d}.0, ${h}.0);
+      return sampleTexture(${r}, uv);
+    }
+  `;
+  }
+  const { newShape: s, keptDims: i } = N(n), c = s;
+  if (c.length < n.length) {
+    const h = B(e, c), d = ["row", "col"];
+    return `
+      ${U(h, t)}
+      float ${o}(int row, int col) {
+        return ${o}(${k(d, i)});
+      }
+    `;
+  }
+  if (e.shapeInfo.isUniform)
+    return `
+      float ${o}(int row, int col) {
+        int index = round(dot(vec2(row, col), vec2(${n[1]}, 1)));
+        ${M(e)}
+      }
+    `;
+  const l = a[0], f = a[1], u = y(r);
+  return f === 1 ? t ? `
+      float ${o}(int row, int col) {
+        float index = dot(vec3(row, col, ${u}), 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, ${u}), vec3(${n[1]}, 1, 1));
+      vec2 uv = vec2(0.5, (index + 0.5) / ${l}.0);
+      return sampleTexture(${r}, uv);
+    }
+  ` : l === 1 ? t ? `
+      float ${o}(int row, int col) {
+        float index = dot(vec3(row, col, ${u}), 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, ${u}), vec3(${n[1]}, 1, 1));
+      vec2 uv = vec2((index + 0.5) / ${f}.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 + ${u};
+        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 + ${u};
+    vec2 uv = uvFromFlat(${l}, ${f}, index);
+    return sampleTexture(${r}, uv);
+  }
+`;
+}
+function Yn(e, t) {
+  const n = e.shapeInfo.logicalShape, r = e.name, o = "get" + r.charAt(0).toUpperCase() + r.slice(1), a = e.shapeInfo.texShape, s = [Math.ceil(a[0] / 2), Math.ceil(a[1] / 2)];
+  if (n[0] === 1) {
+    const h = n.slice(1), d = [1, 2], p = B(e, h), x = ["b", "row", "col"];
+    return `
+        ${ve(p, t)}
+        vec4 ${o}(int b, int row, int col) {
+          return ${o}(${k(x, d)});
+        }
+      `;
+  }
+  const i = b();
+  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 ${i.texture2D}(${r}, uv);
+    }
+  `;
+  const c = s[0], l = s[1], f = Math.ceil(n[2] / 2), u = f * Math.ceil(n[1] / 2);
+  return `
+    vec4 ${o}(int b, int row, int col) {
+      vec2 uv = packedUVfrom3D(
+        ${c}, ${l}, ${u}, ${f}, b, row, col);
+      return ${i.texture2D}(${r}, uv);
+    }
+  `;
+}
+function Kn(e, t) {
+  const n = e.shapeInfo.logicalShape, r = e.name, o = "get" + r.charAt(0).toUpperCase() + r.slice(1), a = n[1] * n[2], s = n[2], { newShape: i, keptDims: c } = N(n), l = i;
+  if (l.length < n.length) {
+    const x = B(e, l), S = ["row", "col", "depth"];
+    return `
+        ${U(x, t)}
+        float ${o}(int row, int col, int depth) {
+          return ${o}(${k(S, c)});
+        }
+      `;
+  }
+  if (e.shapeInfo.isUniform)
+    return `
+      float ${o}(int row, int col, int depth) {
+        int index = round(dot(vec3(row, col, depth),
+                          vec3(${a}, ${s}, 1)));
+        ${M(e)}
+      }
+    `;
+  const f = e.shapeInfo.texShape, u = f[0], h = f[1], d = e.shapeInfo.flatOffset;
+  if (h === a && d == 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(${s}, 1));
+          vec2 uv = (vec2(texC, texR) + halfCR) /
+                     vec2(${h}.0, ${u}.0);
+          return sampleTexture(${r}, uv);
+        }
+      `;
+  if (h === s && d == 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(${h}.0, ${u}.0);
+      return sampleTexture(${r}, uv);
+    }
+  `;
+  const p = y(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 + ${p};
+      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 * ${a} + col * ${s} + depth + ${p};
+        vec2 uv = uvFromFlat(${u}, ${h}, index);
+        return sampleTexture(${r}, uv);
+      }
+  `;
+}
+function Zn(e, t) {
+  const n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1), o = b();
+  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 a = e.shapeInfo.logicalShape, s = a.length, i = e.shapeInfo.texShape, c = [Math.ceil(i[0] / 2), Math.ceil(i[1] / 2)], l = c[0], f = c[1], u = Math.ceil(a[s - 1] / 2);
+  let h = u * Math.ceil(a[s - 2] / 2), d = "int b, int row, int col", p = `b * ${h} + (row / 2) * ${u} + (col / 2)`;
+  for (let x = 2; x < s - 1; x++)
+    d = `int b${x}, ` + d, h *= a[s - x - 1], p = `b${x} * ${h} + ` + p;
+  return `
+    vec4 ${r}(${d}) {
+      int index = ${p};
+      int texR = index / ${f};
+      int texC = index - texR * ${f};
+      vec2 uv = (vec2(texC, texR) + halfCR) / vec2(${f}, ${l});
+      return ${o.texture2D}(${n}, uv);
+    }
+  `;
+}
+function Qn(e, t) {
+  const n = e.shapeInfo.logicalShape, r = e.name, o = "get" + r.charAt(0).toUpperCase() + r.slice(1), a = n[3], s = n[2] * a, i = n[1] * s, { newShape: c, keptDims: l } = N(n);
+  if (c.length < n.length) {
+    const w = B(e, c), F = ["row", "col", "depth", "depth2"];
+    return `
+      ${U(w, t)}
+      float ${o}(int row, int col, int depth, int depth2) {
+        return ${o}(${k(F, l)});
+      }
+    `;
+  }
+  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(${i}, ${s}, ${a}, 1)));
+        ${M(e)}
+      }
+    `;
+  const f = e.shapeInfo.flatOffset, u = e.shapeInfo.texShape, h = u[0], d = u[1], p = `int stride2 = ${r}Shape[3];`, x = `int stride1 = ${r}Shape[2] * stride2;`, S = `int stride0 = ${r}Shape[1] * stride1;`;
+  if (d === i && f == null)
+    return t ? `
+      float ${o}(int row, int col, int depth, int depth2) {
+        ${p}
+        ${x}
+        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(${s}, ${a}, 1));
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                   vec2(${d}.0, ${h}.0);
+        return sampleTexture(${r}, uv);
+      }
+    `;
+  if (d === a && f == 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(${d}.0, ${h}.0);
+        return sampleTexture(${r}, uv);
+      }
+    `;
+  const g = y(r);
+  return t ? `
+    float ${o}(int row, int col, int depth, int depth2) {
+      // Explicitly use integer operations as dot() only works on floats.
+      ${p}
+      ${x}
+      ${S}
+      int index = row * stride0 + col * stride1 +
+          depth * stride2 + depth2;
+      vec2 uv = uvFromFlat(${r}TexShape[0], ${r}TexShape[1], index + ${g});
+      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 * ${i} + col * ${s} +
+          depth * ${a} + depth2;
+      vec2 uv = uvFromFlat(${h}, ${d}, index + ${g});
+      return sampleTexture(${r}, uv);
+    }
+  `;
+}
+function er(e) {
+  const t = e.shapeInfo.logicalShape, n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1), o = t[4], a = t[3] * o, s = t[2] * a, i = t[1] * s, { newShape: c, keptDims: l } = N(t);
+  if (c.length < t.length) {
+    const x = B(e, c), S = ["row", "col", "depth", "depth2", "depth3"];
+    return `
+      ${U(x)}
+      float ${r}(int row, int col, int depth, int depth2, int depth3) {
+        return ${r}(${k(S, l)});
+      }
+    `;
+  }
+  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(${i}, ${s}, ${a}, ${o})) +
+          depth3;
+        ${M(e)}
+      }
+    `;
+  const f = e.shapeInfo.flatOffset, u = e.shapeInfo.texShape, h = u[0], d = u[1];
+  if (d === i && f == 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(${s}, ${a}, ${o}, 1));
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                   vec2(${d}.0, ${h}.0);
+        return sampleTexture(${n}, uv);
+      }
+    `;
+  if (d === o && f == 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(${d}.0, ${h}.0);
+        return sampleTexture(${n}, uv);
+      }
+    `;
+  const p = y(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 * ${i} + col * ${s} + depth * ${a} +
+          depth2 * ${o} + depth3 + ${p};
+      vec2 uv = uvFromFlat(${h}, ${d}, index);
+      return sampleTexture(${n}, uv);
+    }
+  `;
+}
+function tr(e) {
+  const t = e.shapeInfo.logicalShape, n = e.name, r = "get" + n.charAt(0).toUpperCase() + n.slice(1), { newShape: o, keptDims: a } = N(t);
+  if (o.length < t.length) {
+    const S = B(e, o), g = ["row", "col", "depth", "depth2", "depth3", "depth4"];
+    return `
+      ${U(S)}
+      float ${r}(int row, int col, int depth,
+                    int depth2, int depth3, int depth4) {
+        return ${r}(${k(g, a)});
+      }
+    `;
+  }
+  const s = t[5], i = t[4] * s, c = t[3] * i, l = t[2] * c, f = t[1] * l;
+  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(${f}, ${l}, ${c}, ${i})) +
+          dot(
+            vec2(depth3, depth4),
+            vec2(${s}, 1)));
+        ${M(e)}
+      }
+    `;
+  const u = e.shapeInfo.flatOffset, h = e.shapeInfo.texShape, d = h[0], p = h[1];
+  if (p === f && u == 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(${l}, ${c}, ${i}, ${s})) +
+               float(depth4);
+        vec2 uv = (vec2(texC, texR) + halfCR) /
+                   vec2(${p}.0, ${d}.0);
+        return sampleTexture(${n}, uv);
+      }
+    `;
+  if (p === s && u == 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(${p}.0, ${d}.0);
+        return sampleTexture(${n}, uv);
+      }
+    `;
+  const x = y(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 * ${f} + col * ${l} + depth * ${c} +
+          depth2 * ${i} + depth3 * ${s} + depth4 + ${x};
+      vec2 uv = uvFromFlat(${d}, ${p}, index);
+      return sampleTexture(${n}, uv);
+    }
+  `;
+}
+function M(e) {
+  const t = e.name, n = T(e.shapeInfo.logicalShape);
+  return n < 2 ? `return ${t};` : `
+    for (int i = 0; i < ${n}; i++) {
+      if (i == index) {
+        return ${t}[i];
+      }
+    }
+  `;
+}
+function nr(e, t) {
+  const n = e.name, r = n.charAt(0).toUpperCase() + n.slice(1), o = "get" + r + "AtOutCoords", a = e.shapeInfo.logicalShape.length, s = t.logicalShape.length, i = me(e.shapeInfo.logicalShape, t.logicalShape), c = Te(s), l = s - a;
+  let f;
+  const u = ["x", "y", "z", "w", "u", "v"];
+  a === 0 ? f = "" : s < 2 && i.length >= 1 ? f = "coords = 0;" : f = i.map((w) => `coords.${u[w + l]} = 0;`).join(`
+`);
+  let h = "";
+  s < 2 && a > 0 ? h = "coords" : h = e.shapeInfo.logicalShape.map((w, F) => `coords.${u[F + l]}`).join(", ");
+  let d = "return outputValue;";
+  const x = T(e.shapeInfo.logicalShape) === 1, g = T(t.logicalShape) === 1;
+  if (a === 1 && !x && !g)
+    d = `
+      return vec4(outputValue.xy, outputValue.xy);
+    `;
+  else if (x && !g)
+    s === 1 ? d = `
+        return vec4(outputValue.x, outputValue.x, 0., 0.);
+      ` : d = `
+        return vec4(outputValue.x);
+      `;
+  else if (i.length) {
+    const w = a - 2, F = a - 1;
+    i.indexOf(w) > -1 && i.indexOf(F) > -1 ? d = "return vec4(outputValue.x);" : i.indexOf(w) > -1 ? d = "return vec4(outputValue.x, outputValue.y, outputValue.x, outputValue.y);" : i.indexOf(F) > -1 && (d = "return vec4(outputValue.xx, outputValue.zz);");
+  }
+  return `
+    vec4 ${o}() {
+      ${c} coords = getOutputCoords();
+      ${f}
+      vec4 outputValue = get${r}(${h});
+      ${d}
+    }
+  `;
+}
+function rr(e, t) {
+  const n = e.name, r = n.charAt(0).toUpperCase() + n.slice(1), o = "get" + r + "AtOutCoords", a = t.texShape, s = e.shapeInfo.texShape, i = e.shapeInfo.logicalShape.length, c = t.logicalShape.length;
+  if (!e.shapeInfo.isUniform && i === c && e.shapeInfo.flatOffset == null && E(s, a))
+    return `
+      float ${o}() {
+        return sampleTexture(${n}, resultUV);
+      }
+    `;
+  const l = Te(c), f = me(e.shapeInfo.logicalShape, t.logicalShape), u = c - i;
+  let h;
+  const d = ["x", "y", "z", "w", "u", "v"];
+  i === 0 ? h = "" : c < 2 && f.length >= 1 ? h = "coords = 0;" : h = f.map((x) => `coords.${d[x + u]} = 0;`).join(`
+`);
+  let p = "";
+  return c < 2 && i > 0 ? p = "coords" : p = e.shapeInfo.logicalShape.map((x, S) => `coords.${d[S + u]}`).join(", "), `
+    float ${o}() {
+      ${l} coords = getOutputCoords();
+      ${h}
+      return get${r}(${p});
+    }
+  `;
+}
+function Te(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 Z(e, t, n) {
+  const { newShape: r, keptDims: o } = N(t), a = t.length, s = e && a === 3 && t[0] === 1, i = s ? t.slice(1) : r, c = !e && a > 1 && !E(t, n) && r.length < a || s;
+  return { useSqueezeShape: c, uniformShape: c ? i : t, keptDims: o };
+}
+function B(e, t) {
+  const n = JSON.parse(JSON.stringify(e));
+  return n.shapeInfo.logicalShape = t, n;
+}
+function k(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 I = {}, P = {
+  alpha: !1,
+  antialias: !1,
+  premultipliedAlpha: !1,
+  preserveDrawingBuffer: !1,
+  depth: !1,
+  stencil: !1,
+  failIfMajorPerformanceCaveat: !0
+};
+function _r(e, t) {
+  I[e] = t;
+}
+function _(e, t) {
+  if (!(e in I) || t != null) {
+    const r = ar(e, t);
+    if (r !== null)
+      I[e] = r;
+    else
+      return console.log("Could not get context for WebGL version", e), null;
+  }
+  const n = I[e];
+  return n == null || n.isContextLost() ? (delete I[e], _(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), I[e]);
+}
+function or(e) {
+  if (!m().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 ar(e, t) {
+  if (e !== 1 && e !== 2)
+    throw new Error("Cannot get WebGL rendering context, WebGL is disabled.");
+  const n = t ?? or(e);
+  return n.addEventListener("webglcontextlost", (r) => {
+    r.preventDefault(), delete I[e];
+  }, !1), m().getBool("SOFTWARE_WEBGL_ENABLED") && (P.failIfMajorPerformanceCaveat = !1), e === 1 ? (
+    // tslint:disable-next-line
+    n.getContext("webgl", P) || n.getContext("experimental-webgl", P)
+  ) : n.getContext("webgl2", P);
+}
+/**
+ * @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 se;
+(function(e) {
+  e[e.DENSE = 0] = "DENSE", e[e.SHARED_BATCH = 1] = "SHARED_BATCH";
+})(se || (se = {}));
+var ie;
+(function(e) {
+  e[e.RENDER = 0] = "RENDER", e[e.UPLOAD = 1] = "UPLOAD", e[e.PIXELS = 2] = "PIXELS", e[e.DOWNLOAD = 3] = "DOWNLOAD";
+})(ie || (ie = {}));
+var ce;
+(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";
+})(ce || (ce = {}));
+function Ir(e, t) {
+  return [t, e];
+}
+function Or(e, t) {
+  return e * t;
+}
+function Nr(e) {
+  const t = T(e), n = Math.ceil(t / 4);
+  return q(n);
+}
+function sr(e, t) {
+  return [
+    Math.max(1, Math.ceil(t / 2)),
+    Math.max(1, Math.ceil(e / 2))
+  ];
+}
+function yr(e, t) {
+  const [n, r] = sr(e, t);
+  return n * r * 4;
+}
+function Se(e, t) {
+  const n = e;
+  let r, o, a, s, i, c, l, f, u, h;
+  return m().getNumber("WEBGL_VERSION") === 2 ? (r = n.R32F, o = n.R16F, a = n.RGBA16F, s = n.RGBA32F, i = n.RED, l = 4, f = 1, u = n.HALF_FLOAT, h = n.FLOAT, c = n.RGBA8) : (r = e.RGBA, o = e.RGBA, a = e.RGBA, s = n.RGBA, i = e.RGBA, l = 4, f = 4, u = t != null ? t.HALF_FLOAT_OES : null, h = e.FLOAT, c = e.RGBA), {
+    internalFormatFloat: r,
+    internalFormatHalfFloat: o,
+    internalFormatPackedHalfFloat: a,
+    internalFormatPackedFloat: s,
+    textureFormatFloat: i,
+    downloadTextureFormat: c,
+    downloadUnpackNumChannels: l,
+    defaultNumChannels: f,
+    textureTypeHalfFloat: u,
+    textureTypeFloat: h
+  };
+}
+/**
+ * @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 v(e, t) {
+  const n = t();
+  return m().getBool("DEBUG") && ir(e), n;
+}
+function ir(e) {
+  const t = e.getError();
+  if (t !== e.NO_ERROR)
+    throw new Error("WebGL Error: " + lr(e, t));
+}
+const cr = 596e-10, ur = 65504;
+function Lr(e) {
+  return !!(m().getBool("WEBGL_RENDER_FLOAT32_ENABLED") || e === 0 || cr < Math.abs(e) && Math.abs(e) < ur);
+}
+function lr(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 Dr(e, t) {
+  return C(e, () => e.getExtension(t), 'Extension "' + t + '" not supported on this browser.');
+}
+function br(e, t) {
+  const n = C(e, () => e.createShader(e.VERTEX_SHADER), "Unable to create vertex WebGLShader.");
+  if (v(e, () => e.shaderSource(n, t)), v(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 fr(e, t) {
+  const n = C(e, () => e.createShader(e.FRAGMENT_SHADER), "Unable to create fragment WebGLShader.");
+  if (v(e, () => e.shaderSource(n, t)), v(e, () => e.compileShader(n)), m().get("ENGINE_COMPILE_ONLY"))
+    return n;
+  if (e.getShaderParameter(n, e.COMPILE_STATUS) === !1)
+    throw dr(t, e.getShaderInfoLog(n)), new Error("Failed to compile fragment shader.");
+  return n;
+}
+const hr = /ERROR: [0-9]+:([0-9]+):/g;
+function dr(e, t) {
+  const n = hr.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(`
+`), a = o.length.toString().length + 2, s = o.map((u, h) => ee((h + 1).toString(), a) + u);
+  let i = 0;
+  for (let u = 0; u < s.length; u++)
+    i = Math.max(s[u].length, i);
+  const c = s.slice(0, r - 1), l = s.slice(r - 1, r), f = s.slice(r);
+  console.log(c.join(`
+`)), console.log(t.split(`
+`)[0]), console.log(`%c ${ee(l[0], i)}`, "border:1px solid red; background-color:#e3d2d2; color:#a61717"), console.log(f.join(`
+`));
+}
+function Ur(e) {
+  return C(e, () => e.createProgram(), "Unable to create WebGLProgram.");
+}
+function Mr(e, t) {
+  if (v(e, () => e.linkProgram(t)), !m().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 Br(e, t) {
+  if (v(e, () => e.validateProgram(t)), e.getProgramParameter(t, e.VALIDATE_STATUS) === !1)
+    throw console.log(e.getProgramInfoLog(t)), new Error("Shader program validation failed.");
+}
+function kr(e, t) {
+  const n = C(e, () => e.createBuffer(), "Unable to create WebGLBuffer");
+  return v(e, () => e.bindBuffer(e.ARRAY_BUFFER, n)), v(e, () => e.bufferData(e.ARRAY_BUFFER, t, e.STATIC_DRAW)), n;
+}
+function Pr(e, t) {
+  const n = C(e, () => e.createBuffer(), "Unable to create WebGLBuffer");
+  return v(e, () => e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, n)), v(e, () => e.bufferData(e.ELEMENT_ARRAY_BUFFER, t, e.STATIC_DRAW)), n;
+}
+function Wr(e) {
+  return C(e, () => e.createTexture(), "Unable to create WebGLTexture.");
+}
+function Vr(e, t) {
+  const n = m().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 Hr(e) {
+  return C(e, () => e.createFramebuffer(), "Unable to create WebGLFramebuffer.");
+}
+function Xr(e, t, n, r, o, a, s) {
+  const i = e.getAttribLocation(t, n);
+  return i === -1 ? !1 : (v(e, () => e.bindBuffer(e.ARRAY_BUFFER, r)), v(e, () => e.vertexAttribPointer(i, o, e.FLOAT, !1, a, s)), v(e, () => e.enableVertexAttribArray(i)), !0);
+}
+function pr(e, t, n) {
+  mr(e, n), v(e, () => e.activeTexture(e.TEXTURE0 + n)), v(e, () => e.bindTexture(e.TEXTURE_2D, t));
+}
+function Gr(e, t, n) {
+  return C(e, () => e.getUniformLocation(t, n), 'uniform "' + n + '" not present in program.');
+}
+function zr(e, t, n) {
+  return e.getUniformLocation(t, n);
+}
+function qr(e, t, n, r) {
+  v(e, () => pr(e, t, r)), v(e, () => e.uniform1i(n, r));
+}
+function jr(e, t, n) {
+  v(e, () => e.bindFramebuffer(e.FRAMEBUFFER, n)), v(e, () => e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, t, 0));
+}
+function Jr(e, t) {
+  v(e, () => e.bindFramebuffer(e.FRAMEBUFFER, t)), v(e, () => e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, null, 0));
+}
+function Yr(e) {
+  const t = e.checkFramebufferStatus(e.FRAMEBUFFER);
+  if (t !== e.FRAMEBUFFER_COMPLETE)
+    throw new Error("Error binding framebuffer: " + xr(e, t));
+}
+function xr(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 = v(e, () => t());
+  if (r == null)
+    throw new Error(n);
+  return r;
+}
+function mr(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 Ee(e, t = 2) {
+  return T(e.slice(0, e.length - t));
+}
+function Re(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 Kr(e) {
+  let t = [1, 1, 1];
+  return e.length === 0 || e.length === 1 && e[0] === 1 || (t = [Ee(e), ...Re(e)]), t;
+}
+function Zr(e, t = !1) {
+  let n = m().getNumber("WEBGL_MAX_TEXTURE_SIZE"), r = m().getNumber("WEBGL_MAX_SIZE_FOR_NARROW_TEXTURE");
+  r === 1 / 0 && m().getBool("WEBGL_AUTO_SQUARIFY_NARROW_TEXTURE_SHAPE") && (r = n / 2), t && (n = n * 2, r = r * 2, e = e.map((i, c) => c >= e.length - 2 ? ye(e[c]) : e[c]), e.length === 1 && (e = [2, e[0]])), e.length !== 2 && (e = N(e).newShape);
+  let o = T(e), a = null;
+  e.length <= 1 && o <= n ? a = [1, o] : e.length === 2 && e[0] <= n && e[1] <= n ? a = e : e.length === 3 && e[0] * e[1] <= n && e[2] <= n ? a = [e[0] * e[1], e[2]] : e.length === 3 && e[0] <= n && e[1] * e[2] <= n ? a = [e[0], e[1] * e[2]] : e.length === 4 && e[0] * e[1] * e[2] <= n && e[3] <= n ? a = [e[0] * e[1] * e[2], e[3]] : e.length === 4 && e[0] <= n && e[1] * e[2] * e[3] <= n && (a = [e[0], e[1] * e[2] * e[3]]);
+  const s = a != null && Math.max(...a) > r && Math.min(...a) <= (t ? 2 : 1) && Math.min(...a) > 0;
+  if (a == null || s)
+    if (t) {
+      const i = Ee(e);
+      let c = 2, l = 2;
+      e.length && ([c, l] = Re(e)), o = i * (c / 2) * (l / 2), a = q(o).map((f) => f * 2);
+    } else
+      a = q(o);
+  return a;
+}
+function W(e) {
+  return e % 2 === 0;
+}
+function Qr(e, t) {
+  if (e = e.slice(-2), t = t.slice(-2), E(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 || W(n) && W(r) && (e[0] === 1 || t[0] === 1))
+      return !0;
+  }
+  return e[1] === t[1] && W(e[0]) && W(t[0]);
+}
+let X, G;
+function eo(e) {
+  if (X == null) {
+    const t = _(e);
+    X = t.getParameter(t.MAX_TEXTURE_SIZE);
+  }
+  return X;
+}
+function to(e) {
+  if (G == null) {
+    const t = _(e);
+    G = t.getParameter(t.MAX_TEXTURE_IMAGE_UNITS);
+  }
+  return Math.min(16, G);
+}
+function no(e) {
+  if (e === 0)
+    return 0;
+  let t;
+  const n = _(e);
+  return A(n, "EXT_disjoint_timer_query_webgl2") && e === 2 ? t = 2 : A(n, "EXT_disjoint_timer_query") ? t = 1 : t = 0, t;
+}
+function A(e, t) {
+  return e.getExtension(t) != null;
+}
+function ro(e) {
+  try {
+    if (_(e) != null)
+      return !0;
+  } catch (t) {
+    return console.log("Error when getting WebGL context: ", t), !1;
+  }
+  return !1;
+}
+function oo(e) {
+  if (e === 0)
+    return !1;
+  const t = _(e);
+  if (e === 1) {
+    if (!A(t, "OES_texture_float"))
+      return !1;
+  } else if (!A(t, "EXT_color_buffer_float"))
+    return !1;
+  return j(t);
+}
+function ao(e) {
+  if (e === 0)
+    return !1;
+  const t = _(e);
+  if (e === 1) {
+    if (!A(t, "OES_texture_float") || !A(t, "WEBGL_color_buffer_float"))
+      return !1;
+  } else {
+    if (A(t, "EXT_color_buffer_float"))
+      return j(t);
+    const r = "EXT_color_buffer_half_float";
+    if (A(t, r)) {
+      const o = t.getExtension(r);
+      return vr(t, o);
+    }
+    return !1;
+  }
+  return j(t);
+}
+function j(e) {
+  const t = Se(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 a = e.createFramebuffer();
+  e.bindFramebuffer(e.FRAMEBUFFER, a), e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, n, 0);
+  const s = e.checkFramebufferStatus(e.FRAMEBUFFER) === e.FRAMEBUFFER_COMPLETE;
+  return e.bindTexture(e.TEXTURE_2D, null), e.bindFramebuffer(e.FRAMEBUFFER, null), e.deleteTexture(n), e.deleteFramebuffer(a), s;
+}
+function vr(e, t) {
+  const n = Se(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 s = e.createFramebuffer();
+  e.bindFramebuffer(e.FRAMEBUFFER, s), e.framebufferTexture2D(e.FRAMEBUFFER, e.COLOR_ATTACHMENT0, e.TEXTURE_2D, r, 0);
+  const i = e.checkFramebufferStatus(e.FRAMEBUFFER) === e.FRAMEBUFFER_COMPLETE;
+  return e.bindTexture(e.TEXTURE_2D, null), e.bindFramebuffer(e.FRAMEBUFFER, null), e.deleteTexture(r), e.deleteFramebuffer(s), i;
+}
+function so(e) {
+  return e !== 2 ? !1 : _(e).fenceSync != null;
+}
+function io(e, t) {
+  Array.isArray(e) || (e = [e]), e.forEach((n) => {
+    n != null && $(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 co(e, t, n, r) {
+  const o = n.map((f, u) => {
+    const h = {
+      logicalShape: f.shape,
+      texShape: f.isUniform ? null : f.texData.texShape,
+      isUniform: f.isUniform,
+      isPacked: f.isUniform ? !1 : f.texData.isPacked,
+      flatOffset: null
+    };
+    return f.texData != null && f.texData.slice != null && f.texData.slice.flatOffset > 0 && (h.flatOffset = f.texData.slice.flatOffset), { name: t.variableNames[u], shapeInfo: h };
+  }), a = o.map((f) => f.shapeInfo), s = {
+    logicalShape: r.shape,
+    texShape: r.texData.texShape,
+    isUniform: !1,
+    isPacked: r.texData.isPacked,
+    flatOffset: null
+  }, i = Rn(o, s, t), c = fr(e.gl, i), l = e.createProgram(c);
+  return m().get("ENGINE_COMPILE_ONLY") ? {
+    program: t,
+    fragmentShader: c,
+    source: i,
+    webGLProgram: l,
+    inShapeInfos: a,
+    outShapeInfo: s,
+    variablesLocations: null,
+    customUniformLocations: null,
+    infLoc: null,
+    nanLoc: null,
+    outShapeLocation: null,
+    outShapeStridesLocation: null,
+    outTexShapeLocation: null
+  } : (e.buildVao(l), Object.assign({
+    program: t,
+    fragmentShader: c,
+    source: i,
+    webGLProgram: l,
+    inShapeInfos: a,
+    outShapeInfo: s
+  }, $r(e, t, l)));
+}
+function $r(e, t, n) {
+  const r = [], o = [];
+  let a, s, i, c = null, l = null;
+  l = e.getUniformLocation(n, "NAN", !1), m().getNumber("WEBGL_VERSION") === 1 && (c = e.getUniformLocation(n, "INFINITY", !1));
+  const f = !1;
+  for (const u of t.variableNames) {
+    const h = {
+      name: u,
+      uniform: e.getUniformLocation(n, u, f),
+      offset: e.getUniformLocation(n, `offset${u}`, f)
+    };
+    t.enableShapeUniforms && (h.shape = e.getUniformLocation(n, `${u}Shape`, f), h.texShape = e.getUniformLocation(n, `${u}TexShape`, f)), r.push(h);
+  }
+  if (t.enableShapeUniforms && (a = e.getUniformLocation(n, "outShape", f), i = e.getUniformLocation(n, "outShapeStrides", f), s = e.getUniformLocation(n, "outTexShape", f)), t.customUniforms)
+    for (const u of t.customUniforms)
+      o.push(e.getUniformLocation(n, u.name, f));
+  return {
+    variablesLocations: r,
+    customUniformLocations: o,
+    infLoc: c,
+    nanLoc: l,
+    outShapeLocation: a,
+    outShapeStridesLocation: i,
+    outTexShapeLocation: s
+  };
+}
+function ue(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, a = t[r], s = a.shape;
+    if (!E(o, s))
+      throw Error(`Binary was compiled with different shapes than the current args. Shapes ${o} and ${s} must match`);
+    if (n.isUniform && a.isUniform)
+      return;
+    const i = n.texShape, c = a.isUniform ? null : a.texData.texShape;
+    if (!E(i, c))
+      throw Error(`Binary was compiled with different texture shapes than the current args. Shape ${i} and ${c} must match`);
+  });
+}
+function uo(e, t, n, r, o) {
+  t.program.enableShapeUniforms || (ue(t.inShapeInfos, n), ue([t.outShapeInfo], [r]));
+  const a = r.texData.texture, s = r.texData.texShape;
+  r.texData.isPacked ? e.setOutputPackedMatrixTexture(a.texture, s[0], s[1]) : e.setOutputMatrixTexture(a.texture, s[0], s[1]), e.setProgram(t.webGLProgram), e.bindVertexArray(t.webGLProgram.vao), m().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 l = n[c], { uniform: f, offset: u, shape: h, texShape: d } = t.variablesLocations[c];
+    if (h) {
+      const { uniformShape: p } = Z(t.program.packedInputs, l.shape, l.texData.texShape);
+      switch (p.length) {
+        case 1:
+          e.gl.uniform1iv(h, new Int32Array(p));
+          break;
+        case 2:
+          e.gl.uniform2iv(h, new Int32Array(p));
+          break;
+        case 3:
+          e.gl.uniform3iv(h, new Int32Array(p));
+          break;
+        case 4:
+          e.gl.uniform4iv(h, new Int32Array(p));
+          break;
+      }
+    }
+    if (d && e.gl.uniform2i(d, l.texData.texShape[0], l.texData.texShape[1]), f != null) {
+      if (l.isUniform) {
+        if (T(l.shape) < 2)
+          e.gl.uniform1f(f, l.uniformValues[0]);
+        else {
+          let p = l.uniformValues;
+          p instanceof Float32Array || (p = new Float32Array(p)), e.gl.uniform1fv(f, p);
+        }
+        continue;
+      }
+      l.texData.slice != null && u != null && e.gl.uniform1i(u, l.texData.slice.flatOffset), e.setInputMatrixTexture(l.texData.texture.texture, f, c);
+    }
+  }
+  const i = t.outShapeLocation;
+  if (i)
+    switch (r.shape.length) {
+      case 1:
+        e.gl.uniform1iv(i, new Int32Array(r.shape));
+        break;
+      case 2:
+        e.gl.uniform2iv(i, new Int32Array(r.shape));
+        break;
+      case 3:
+        e.gl.uniform3iv(i, new Int32Array(r.shape));
+        break;
+      case 4:
+        e.gl.uniform4iv(i, new Int32Array(r.shape));
+        break;
+    }
+  if (t.outShapeStridesLocation) {
+    const c = D(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 l = t.program.customUniforms[c], f = t.customUniformLocations[c], u = o[c];
+      if (l.type === "float")
+        e.gl.uniform1fv(f, u);
+      else if (l.type === "vec2")
+        e.gl.uniform2fv(f, u);
+      else if (l.type === "vec3")
+        e.gl.uniform3fv(f, u);
+      else if (l.type === "vec4")
+        e.gl.uniform4fv(f, u);
+      else if (l.type === "int")
+        e.gl.uniform1iv(f, u);
+      else if (l.type === "ivec2")
+        e.gl.uniform2iv(f, u);
+      else if (l.type === "ivec3")
+        e.gl.uniform3iv(f, u);
+      else if (l.type === "ivec4")
+        e.gl.uniform4iv(f, u);
+      else
+        throw Error(`uniform type ${l.type} is not supported yet.`);
+    }
+  e.executeProgram();
+}
+function lo(e, t, n) {
+  let r = "";
+  t.concat(n).forEach((s) => {
+    const i = s.texData != null && s.texData.slice != null && s.texData.slice.flatOffset > 0;
+    if (e.enableShapeUniforms && !s.isUniform) {
+      const c = s.texData.texShape, { useSqueezeShape: l, uniformShape: f, keptDims: u } = Z(e.packedInputs, s.shape, c);
+      let h = "", d = "", p = "";
+      if (f.length === 1 && e.packedInputs) {
+        const L = [Math.ceil(c[0] / 2), Math.ceil(c[1] / 2)];
+        h = `${L[0] > 1}_${L[1] > 1}`;
+      } else if (f.length === 2 && !e.packedInputs)
+        d = `${f[0] > 1}_${f[1] > 1}`;
+      else if (f.length > 2 && !e.packedInputs) {
+        const L = D(f);
+        p = `${L[0] === c[1]}_${L[L.length - 1] === c[1]}`;
+      }
+      const x = s.shape.length, S = f.length === 2 && E(s.shape, c), g = T(s.shape) === 1, w = de(s.shape, n.shape), F = !e.packedInputs && x === n.shape.length && E(c, n.texData.texShape), ge = e.packedInputs || f.length > 2 ? "" : `${c[0] > 1}_${c[1] > 1}`;
+      r += `${x}_${F}_${l ? u : ""}_${f.length}_${g}_${w}_${S}_${h}_${d}_${p}_${ge}_${i}`;
+    } else {
+      const c = s.isUniform ? "uniform" : s.texData.texShape;
+      r += `${s.shape}_${c}_${i}`;
+    }
+  });
+  const o = e.userCode;
+  let a = e.constructor.name;
+  return a += "_" + r + "_" + o + `${m().getNumber("WEBGL_VERSION")}`, a;
+}
+function fo(e) {
+  return m().getBool("WEBGL_USE_SHAPES_UNIFORMS") && e <= 4;
+}
+export {
+  Xt as $,
+  fn as A,
+  hn as B,
+  dn as C,
+  _t as D,
+  It as E,
+  Ot as F,
+  Nt as G,
+  yt as H,
+  St as I,
+  Et as J,
+  jt as K,
+  Yt as L,
+  Kt as M,
+  Jt as N,
+  Zt as O,
+  Bt as P,
+  Mt as Q,
+  R,
+  Ut as S,
+  bt as T,
+  Dt as U,
+  Lt as V,
+  Ht as W,
+  Pt as X,
+  Wt as Y,
+  Vt as Z,
+  Gt as _,
+  Cr as a,
+  zt as a0,
+  Tt as a1,
+  mn as a2,
+  At as a3,
+  en as a4,
+  ro as a5,
+  eo as a6,
+  to as a7,
+  no as a8,
+  oo as a9,
+  Br as aA,
+  Gr as aB,
+  zr as aC,
+  qr as aD,
+  Yr as aE,
+  jr as aF,
+  _r as aG,
+  ce as aH,
+  Kr as aI,
+  Nr as aJ,
+  Lr as aK,
+  lo as aL,
+  co as aM,
+  uo as aN,
+  Zr as aO,
+  dr as aP,
+  $r as aQ,
+  io as aR,
+  xn as aS,
+  pn as aT,
+  ao as aa,
+  so as ab,
+  se as ac,
+  b as ad,
+  xe as ae,
+  ie as af,
+  Ar as ag,
+  kr as ah,
+  Pr as ai,
+  v as aj,
+  Ir as ak,
+  br as al,
+  Xr as am,
+  Vr as an,
+  Wr as ao,
+  sr as ap,
+  Or as aq,
+  yr as ar,
+  _ as as,
+  Dr as at,
+  A as au,
+  Hr as av,
+  Se as aw,
+  Jr as ax,
+  Ur as ay,
+  Mr as az,
+  wr as b,
+  V as c,
+  Ee as d,
+  Re as e,
+  Te as f,
+  Fr as g,
+  $n as h,
+  Qr as i,
+  Ft as j,
+  gt as k,
+  wt as l,
+  kt as m,
+  Rt as n,
+  Tn as o,
+  tn as p,
+  nn as q,
+  rn as r,
+  on as s,
+  an as t,
+  fo as u,
+  Ct as v,
+  sn as w,
+  cn as x,
+  un as y,
+  ln as z
+};