@genai-fi/nanogpt 0.0.1

package/dist/index-B8nyc6IR.js

@@ -0,0 +1,3899 @@
+/**
+ * @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.
+ * =============================================================================
+ */
+class we {
+  refCount(t) {
+    return v("refCount");
+  }
+  incRef(t) {
+    return v("incRef");
+  }
+  timerAvailable() {
+    return !0;
+  }
+  time(t) {
+    return v("time");
+  }
+  read(t) {
+    return v("read");
+  }
+  readSync(t) {
+    return v("readSync");
+  }
+  readToGPU(t, e) {
+    return v("readToGPU");
+  }
+  numDataIds() {
+    return v("numDataIds");
+  }
+  disposeData(t, e) {
+    return v("disposeData");
+  }
+  write(t, e, s) {
+    return v("write");
+  }
+  move(t, e, s, r, i) {
+    return v("move");
+  }
+  createTensorFromGPUData(t, e, s) {
+    return v("createTensorFromGPUData");
+  }
+  memory() {
+    return v("memory");
+  }
+  /** Returns the highest precision for floats in bits (e.g. 16 or 32) */
+  floatPrecision() {
+    return v("floatPrecision");
+  }
+  /** Returns the smallest representable number.  */
+  epsilon() {
+    return this.floatPrecision() === 32 ? 1e-7 : 1e-4;
+  }
+  dispose() {
+    return v("dispose");
+  }
+}
+function v(n) {
+  throw new Error(`'${n}' not yet implemented or not found in the registry. This kernel may not be supported by the tfjs backend you have chosen`);
+}
+/**
+ * @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 b(n, t) {
+  if (!n)
+    throw new Error(typeof t == "string" ? t : t());
+}
+function ds(n, t, e = "") {
+  b(vt(n, t), () => e + ` Shapes ${n} and ${t} must match`);
+}
+function U(n) {
+  if (n.length === 0)
+    return 1;
+  let t = n[0];
+  for (let e = 1; e < n.length; e++)
+    t *= n[e];
+  return t;
+}
+function vt(n, t) {
+  if (n === t)
+    return !0;
+  if (n == null || t == null || n.length !== t.length)
+    return !1;
+  for (let e = 0; e < n.length; e++)
+    if (n[e] !== t[e])
+      return !1;
+  return !0;
+}
+function lt(n, t) {
+  return t <= n.length ? n : n + " ".repeat(t - n.length);
+}
+function Se(n, t) {
+  let e = null;
+  if (n == null || n === "float32")
+    e = new Float32Array(t);
+  else if (n === "int32")
+    e = new Int32Array(t);
+  else if (n === "bool")
+    e = new Uint8Array(t);
+  else if (n === "string")
+    e = new Array(t);
+  else
+    throw new Error(`Unknown data type ${n}`);
+  return e;
+}
+function Ie(n, t) {
+  for (let e = 0; e < n.length; e++) {
+    const s = n[e];
+    if (isNaN(s) || !isFinite(s))
+      throw Error(`A tensor of type ${t} being uploaded contains ${s}.`);
+  }
+}
+function ke(n) {
+  return n === "bool" || n === "complex64" || n === "float32" || n === "int32" || n === "string";
+}
+function yt(n) {
+  if (n === "float32" || n === "int32")
+    return 4;
+  if (n === "complex64")
+    return 8;
+  if (n === "bool")
+    return 1;
+  throw new Error(`Unknown dtype ${n}`);
+}
+function Te(n) {
+  if (n == null)
+    return 0;
+  let t = 0;
+  return n.forEach((e) => t += e.length), t;
+}
+function Mt(n) {
+  return typeof n == "string" || n instanceof String;
+}
+function Ee(n) {
+  return typeof n == "boolean";
+}
+function Be(n) {
+  return typeof n == "number";
+}
+function ft(n) {
+  return Array.isArray(n) ? ft(n[0]) : n instanceof Float32Array ? "float32" : n instanceof Int32Array || n instanceof Uint8Array || n instanceof Uint8ClampedArray ? "int32" : Be(n) ? "float32" : Mt(n) ? "string" : Ee(n) ? "bool" : "float32";
+}
+function bt(n) {
+  return !!(n && n.constructor && n.call && n.apply);
+}
+function Ft(n) {
+  const t = n.length;
+  if (t < 2)
+    return [];
+  const e = new Array(t - 1);
+  e[t - 2] = n[t - 1];
+  for (let s = t - 3; s >= 0; --s)
+    e[s] = e[s + 1] * n[s + 1];
+  return e;
+}
+function qt(n, t, e, s = !1) {
+  const r = new Array();
+  if (t.length === 1) {
+    const i = t[0] * (s ? 2 : 1);
+    for (let o = 0; o < i; o++)
+      r[o] = e[n + o];
+  } else {
+    const i = t[0], o = t.slice(1), a = o.reduce((c, l) => c * l) * (s ? 2 : 1);
+    for (let c = 0; c < i; c++)
+      r[c] = qt(n + c * a, o, e, s);
+  }
+  return r;
+}
+function Dt(n, t, e = !1) {
+  if (n.length === 0)
+    return t[0];
+  const s = n.reduce((r, i) => r * i) * (e ? 2 : 1);
+  if (s === 0)
+    return [];
+  if (s !== t.length)
+    throw new Error(`[${n}] does not match the input size ${t.length}${e ? " for a complex tensor" : ""}.`);
+  return qt(0, n, t, e);
+}
+function Ae(n, t) {
+  const e = Ht(n, t);
+  for (let s = 0; s < e.length; s++)
+    e[s] = 1;
+  return e;
+}
+function Ht(n, t) {
+  if (t == null || t === "float32" || t === "complex64")
+    return new Float32Array(n);
+  if (t === "int32")
+    return new Int32Array(n);
+  if (t === "bool")
+    return new Uint8Array(n);
+  throw new Error(`Unknown data type ${t}`);
+}
+function Rt(n) {
+  n.forEach((t) => {
+    b(Number.isInteger(t) && t >= 0, () => `Tensor must have a shape comprised of positive integers but got shape [${n}].`);
+  });
+}
+function xt(n) {
+  return n && n.then && typeof n.then == "function";
+}
+/**
+ * @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 Ct = "tfjsflags";
+class ve {
+  // tslint:disable-next-line: no-any
+  constructor(t) {
+    this.global = t, this.flags = {}, this.flagRegistry = {}, this.urlFlags = {}, this.getQueryParams = Me, this.populateURLFlags();
+  }
+  setPlatform(t, e) {
+    this.platform != null && (S().getBool("IS_TEST") || S().getBool("PROD") || console.warn(`Platform ${this.platformName} has already been set. Overwriting the platform with ${t}.`)), this.platformName = t, this.platform = e;
+  }
+  registerFlag(t, e, s) {
+    if (this.flagRegistry[t] = { evaluationFn: e, setHook: s }, this.urlFlags[t] != null) {
+      const r = this.urlFlags[t];
+      S().getBool("IS_TEST") || S().getBool("PROD") || console.warn(`Setting feature override from URL ${t}: ${r}.`), this.set(t, r);
+    }
+  }
+  async getAsync(t) {
+    return t in this.flags ? this.flags[t] : (this.flags[t] = await this.evaluateFlag(t), this.flags[t]);
+  }
+  get(t) {
+    if (t in this.flags)
+      return this.flags[t];
+    const e = this.evaluateFlag(t);
+    if (xt(e))
+      throw new Error(`Flag ${t} cannot be synchronously evaluated. Please use getAsync() instead.`);
+    return this.flags[t] = e, this.flags[t];
+  }
+  getNumber(t) {
+    return this.get(t);
+  }
+  getBool(t) {
+    return this.get(t);
+  }
+  getString(t) {
+    return this.get(t);
+  }
+  getFlags() {
+    return this.flags;
+  }
+  // For backwards compatibility.
+  get features() {
+    return this.flags;
+  }
+  set(t, e) {
+    if (this.flagRegistry[t] == null)
+      throw new Error(`Cannot set flag ${t} as it has not been registered.`);
+    this.flags[t] = e, this.flagRegistry[t].setHook != null && this.flagRegistry[t].setHook(e);
+  }
+  evaluateFlag(t) {
+    if (this.flagRegistry[t] == null)
+      throw new Error(`Cannot evaluate flag '${t}': no evaluation function found.`);
+    return this.flagRegistry[t].evaluationFn();
+  }
+  setFlags(t) {
+    this.flags = Object.assign({}, t);
+  }
+  reset() {
+    this.flags = {}, this.urlFlags = {}, this.populateURLFlags();
+  }
+  populateURLFlags() {
+    if (typeof this.global > "u" || typeof this.global.location > "u" || typeof this.global.location.search > "u")
+      return;
+    const t = this.getQueryParams(this.global.location.search);
+    Ct in t && t[Ct].split(",").forEach((s) => {
+      const [r, i] = s.split(":");
+      this.urlFlags[r] = Re(r, i);
+    });
+  }
+}
+function Me(n) {
+  const t = {};
+  return n.replace(/[?&]([^=?&]+)(?:=([^&]*))?/g, (e, ...s) => (Fe(t, s[0], s[1]), s.join("="))), t;
+}
+function Fe(n, t, e) {
+  n[decodeURIComponent(t)] = decodeURIComponent(e || "");
+}
+function Re(n, t) {
+  const e = t.toLowerCase();
+  return e === "true" || e === "false" ? e === "true" : `${+e}` === e ? +e : t;
+}
+function S() {
+  return Jt;
+}
+let Jt = null;
+function xe(n) {
+  Jt = n;
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+let dt;
+function Xt() {
+  if (dt == null) {
+    let n;
+    if (typeof window < "u")
+      n = window;
+    else if (typeof global < "u")
+      n = global;
+    else if (typeof process < "u")
+      n = process;
+    else if (typeof self < "u")
+      n = self;
+    else
+      throw new Error("Could not find a global object");
+    dt = n;
+  }
+  return dt;
+}
+function Ne() {
+  const n = Xt();
+  return n._tfGlobals == null && (n._tfGlobals = /* @__PURE__ */ new Map()), n._tfGlobals;
+}
+function Nt(n, t) {
+  const e = Ne();
+  if (e.has(n))
+    return e.get(n);
+  {
+    const s = t();
+    return e.set(n, s), e.get(n);
+  }
+}
+const $e = "Abs", Yt = "Add", gs = "BatchMatMul", Qt = "Cast", ms = "Complex", De = "ComplexAbs", Ce = "RealDiv", ps = "Elu", _e = "Fill", Oe = "FloorDiv", Zt = "Identity", ys = "Imag", bs = "LeakyRelu", Pe = "Maximum", Le = "Multiply", ws = "Neg", Ue = "Pow", Ss = "Prelu", Is = "Real", ks = "Relu", Ts = "Reshape", Es = "Relu6", Bs = "Sigmoid", Ge = "Sqrt", As = "Sum", ze = "Sub", vs = "Transpose", We = "ZerosLike", Ms = "Step", Fs = "_FusedMatMul";
+/**
+ * @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 nt(...n) {
+  S().getBool("IS_TEST") || S().getBool("PROD") || console.warn(...n);
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+const te = Nt("kernelRegistry", () => /* @__PURE__ */ new Map()), je = Nt("gradRegistry", () => /* @__PURE__ */ new Map());
+function _t(n, t) {
+  const e = Ke(n, t);
+  return te.get(e);
+}
+function Ot(n) {
+  return je.get(n);
+}
+function Pt(n) {
+  const t = te.entries(), e = [];
+  for (; ; ) {
+    const { done: s, value: r } = t.next();
+    if (s)
+      break;
+    const [i, o] = r, [a] = i.split("_");
+    a === n && e.push(o);
+  }
+  return e;
+}
+function Ke(n, t) {
+  return `${t}_${n}`;
+}
+/**
+ * @license
+ * Copyright 2023 Google LLC.
+ * 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 ee(n) {
+  return n instanceof Float32Array || n instanceof Int32Array || n instanceof Uint8Array || n instanceof Uint8ClampedArray;
+}
+/**
+ * @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 Ve(n, t) {
+  return n instanceof Float32Array && t === "float32" || n instanceof Int32Array && t === "int32" || n instanceof Uint8Array && t === "bool";
+}
+function ne(n, t) {
+  if (t === "string")
+    throw new Error("Cannot convert a string[] to a TypedArray");
+  if (Array.isArray(n) && (n = ot(n)), S().getBool("DEBUG") && Ie(n, t), Ve(n, t))
+    return n;
+  if (t == null || t === "float32" || t === "complex64")
+    return new Float32Array(n);
+  if (t === "int32")
+    return new Int32Array(n);
+  if (t === "bool") {
+    const e = new Uint8Array(n.length);
+    for (let s = 0; s < e.length; ++s)
+      Math.round(n[s]) !== 0 && (e[s] = 1);
+    return e;
+  } else
+    throw new Error(`Unknown data type ${t}`);
+}
+function ut() {
+  return S().platform.now();
+}
+function qe(n, t = "utf-8") {
+  return t = t || "utf-8", S().platform.encode(n, t);
+}
+function Lt(n, t = "utf-8") {
+  return t = t || "utf-8", S().platform.decode(n, t);
+}
+function R(n) {
+  return S().platform.isTypedArray != null ? S().platform.isTypedArray(n) : ee(n);
+}
+function ot(n, t = [], e = !1) {
+  if (t == null && (t = []), typeof n == "boolean" || typeof n == "number" || typeof n == "string" || xt(n) || n == null || R(n) && e)
+    t.push(n);
+  else if (Array.isArray(n) || R(n))
+    for (let s = 0; s < n.length; ++s)
+      ot(n[s], t, e);
+  else {
+    let s = -1;
+    for (const r of Object.keys(n))
+      /^([1-9]+[0-9]*|0)$/.test(r) && (s = Math.max(s, Number(r)));
+    for (let r = 0; r <= s; r++)
+      ot(n[r], t, e);
+  }
+  return t;
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+class He {
+  constructor(t, e) {
+    this.backendTimer = t, this.logger = e, e == null && (this.logger = new Xe());
+  }
+  profileKernel(t, e, s) {
+    let r;
+    const i = () => {
+      r = s();
+    };
+    let o;
+    const a = ut();
+    if (this.backendTimer.timerAvailable())
+      o = this.backendTimer.time(i);
+    else {
+      i();
+      for (const l of r)
+        l.dataSync();
+      o = Promise.resolve({ kernelMs: ut() - a });
+    }
+    if (S().getBool("CHECK_COMPUTATION_FOR_ERRORS"))
+      for (let l = 0; l < r.length; l++) {
+        const u = r[l];
+        u.data().then((h) => {
+          Je(h, u.dtype, t);
+        });
+      }
+    return {
+      kernelName: t,
+      outputs: r,
+      inputs: e,
+      timeMs: o.then((l) => l.kernelMs),
+      extraInfo: o.then((l) => l.getExtraProfileInfo != null ? l.getExtraProfileInfo() : "")
+    };
+  }
+  logKernelProfile(t) {
+    const { kernelName: e, outputs: s, timeMs: r, inputs: i, extraInfo: o } = t;
+    s.forEach((a) => {
+      Promise.all([a.data(), r, o]).then((c) => {
+        this.logger.logKernelProfile(e, a, c[0], c[1], i, c[2]);
+      });
+    });
+  }
+}
+function Je(n, t, e) {
+  if (t !== "float32")
+    return !1;
+  for (let s = 0; s < n.length; s++) {
+    const r = n[s];
+    if (isNaN(r) || !isFinite(r))
+      return console.warn(`Found ${r} in the result of '${e}'`), !0;
+  }
+  return !1;
+}
+class Xe {
+  logKernelProfile(t, e, s, r, i, o) {
+    const a = typeof r == "number" ? lt(`${r}ms`, 9) : r.error, c = lt(t, 25), l = e.rank, u = e.size, h = lt(e.shape.toString(), 14);
+    let f = "";
+    for (const m in i) {
+      const y = i[m];
+      if (y != null) {
+        const d = y.shape || e.shape, I = d.length;
+        f += `${m}: ${I}D ${I > 0 ? d : ""} `;
+      }
+    }
+    console.log(`%c${c}	%c${a}	%c${l}D ${h}	%c${u}	%c${f}	%c${o}`, "font-weight:bold", "color:red", "color:blue", "color: orange", "color: green", "color: steelblue");
+  }
+}
+/**
+ * @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 Ye(n, t, e) {
+  const s = {}, r = {};
+  for (let c = 0; c < t.length; c++)
+    s[t[c].id] = !0;
+  for (let c = 0; c < n.length; c++) {
+    const l = n[c], u = l.inputs;
+    for (const h in u) {
+      const f = u[h];
+      let m = !1;
+      for (let y = 0; y < t.length; y++)
+        if (s[f.id]) {
+          l.outputs.forEach((d) => s[d.id] = !0), m = !0, r[l.id] = !0;
+          break;
+        }
+      if (m)
+        break;
+    }
+  }
+  const i = {};
+  i[e.id] = !0;
+  const o = {};
+  for (let c = n.length - 1; c >= 0; c--) {
+    const l = n[c], u = l.inputs;
+    for (let h = 0; h < l.outputs.length; h++)
+      if (i[l.outputs[h].id]) {
+        for (const f in u)
+          i[u[f].id] = !0, o[l.id] = !0;
+        break;
+      }
+  }
+  const a = [];
+  for (let c = 0; c < n.length; c++) {
+    const l = n[c];
+    if (r[l.id] && o[l.id]) {
+      const u = {};
+      for (const f in l.inputs) {
+        const m = l.inputs[f];
+        s[m.id] && (u[f] = m);
+      }
+      const h = Object.assign({}, l);
+      h.inputs = u, h.outputs = l.outputs, a.push(h);
+    }
+  }
+  return a;
+}
+function Qe(n, t, e, s) {
+  for (let r = t.length - 1; r >= 0; r--) {
+    const i = t[r], o = [];
+    if (i.outputs.forEach((c) => {
+      const l = n[c.id];
+      l != null ? o.push(l) : o.push(null);
+    }), i.gradient == null)
+      throw new Error(`Cannot compute gradient: gradient function not found for ${i.kernelName}.`);
+    const a = i.gradient(o);
+    for (const c in i.inputs) {
+      if (!(c in a))
+        throw new Error(`Cannot backprop through input ${c}. Available gradients found: ${Object.keys(a)}.`);
+      const l = e(() => a[c]());
+      if (l.dtype !== "float32")
+        throw new Error(`Error in gradient for op ${i.kernelName}. The gradient of input ${c} must have 'float32' dtype, but has '${l.dtype}'`);
+      const u = i.inputs[c];
+      if (!vt(l.shape, u.shape))
+        throw new Error(`Error in gradient for op ${i.kernelName}. The gradient of input '${c}' has shape '${l.shape}', which does not match the shape of the input '${u.shape}'`);
+      if (n[u.id] == null)
+        n[u.id] = l;
+      else {
+        const h = n[u.id];
+        n[u.id] = s(h, l), h.dispose();
+      }
+    }
+  }
+}
+/**
+ * @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 Ut = 20, st = 3, gt = 7;
+function Ze(n, t, e, s) {
+  const r = Ft(t), i = tn(n, t, e, r), o = t.length, a = ct(n, t, e, r, i), c = ["Tensor"];
+  return s && (c.push(`  dtype: ${e}`), c.push(`  rank: ${o}`), c.push(`  shape: [${t}]`), c.push("  values:")), c.push(a.map((l) => "    " + l).join(`
+`)), c.join(`
+`);
+}
+function tn(n, t, e, s) {
+  const r = U(t), i = s[s.length - 1], o = new Array(i).fill(0), a = t.length, c = e === "complex64" ? it(n) : n;
+  if (a > 1)
+    for (let l = 0; l < r / i; l++) {
+      const u = l * i;
+      for (let h = 0; h < i; h++)
+        o[h] = Math.max(o[h], rt(c[u + h], 0, e).length);
+    }
+  return o;
+}
+function rt(n, t, e) {
+  let s;
+  return Array.isArray(n) ? s = `${parseFloat(n[0].toFixed(gt))} + ${parseFloat(n[1].toFixed(gt))}j` : Mt(n) ? s = `'${n}'` : e === "bool" ? s = se(n) : s = parseFloat(n.toFixed(gt)).toString(), lt(s, t);
+}
+function se(n) {
+  return n === 0 ? "false" : "true";
+}
+function ct(n, t, e, s, r, i = !0) {
+  const o = e === "complex64" ? 2 : 1, a = t[0], c = t.length;
+  if (c === 0) {
+    if (e === "complex64") {
+      const d = it(n);
+      return [rt(d[0], 0, e)];
+    }
+    return e === "bool" ? [se(n[0])] : [n[0].toString()];
+  }
+  if (c === 1) {
+    if (a > Ut) {
+      const I = st * o;
+      let T = Array.from(n.slice(0, I)), tt = Array.from(n.slice((a - st) * o, a * o));
+      return e === "complex64" && (T = it(T), tt = it(tt)), [
+        "[" + T.map((q, H) => rt(q, r[H], e)).join(", ") + ", ..., " + tt.map((q, H) => rt(q, r[a - st + H], e)).join(", ") + "]"
+      ];
+    }
+    return [
+      "[" + (e === "complex64" ? it(n) : Array.from(n)).map((I, T) => rt(I, r[T], e)).join(", ") + "]"
+    ];
+  }
+  const l = t.slice(1), u = s.slice(1), h = s[0] * o, f = [];
+  if (a > Ut) {
+    for (let d = 0; d < st; d++) {
+      const I = d * h, T = I + h;
+      f.push(...ct(
+        n.slice(I, T),
+        l,
+        e,
+        u,
+        r,
+        !1
+        /* isLast */
+      ));
+    }
+    f.push("...");
+    for (let d = a - st; d < a; d++) {
+      const I = d * h, T = I + h;
+      f.push(...ct(
+        n.slice(I, T),
+        l,
+        e,
+        u,
+        r,
+        d === a - 1
+        /* isLast */
+      ));
+    }
+  } else
+    for (let d = 0; d < a; d++) {
+      const I = d * h, T = I + h;
+      f.push(...ct(
+        n.slice(I, T),
+        l,
+        e,
+        u,
+        r,
+        d === a - 1
+        /* isLast */
+      ));
+    }
+  const m = c === 2 ? "," : "";
+  f[0] = "[" + (a > 0 ? f[0] + m : "");
+  for (let d = 1; d < f.length - 1; d++)
+    f[d] = " " + f[d] + m;
+  let y = `,
+`;
+  for (let d = 2; d < c; d++)
+    y += `
+`;
+  return f[f.length - 1] = " " + f[f.length - 1] + "]" + (i ? "" : y), f;
+}
+function it(n) {
+  const t = [];
+  for (let e = 0; e < n.length; e += 2)
+    t.push([n[e], n[e + 1]]);
+  return t;
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+class en {
+  constructor(t, e, s) {
+    if (this.dtype = e, this.shape = t.slice(), this.size = U(t), s != null) {
+      const r = s.length;
+      b(r === this.size, () => `Length of values '${r}' does not match the size inferred by the shape '${this.size}'.`);
+    }
+    if (e === "complex64")
+      throw new Error("complex64 dtype TensorBuffers are not supported. Please create a TensorBuffer for the real and imaginary parts separately and call tf.complex(real, imag).");
+    this.values = s || Se(e, this.size), this.strides = Ft(t);
+  }
+  /**
+   * Sets a value in the buffer at a given location.
+   *
+   * @param value The value to set.
+   * @param locs  The location indices.
+   *
+   * @doc {heading: 'Tensors', subheading: 'Creation'}
+   */
+  set(t, ...e) {
+    e.length === 0 && (e = [0]), b(e.length === this.rank, () => `The number of provided coordinates (${e.length}) must match the rank (${this.rank})`);
+    const s = this.locToIndex(e);
+    this.values[s] = t;
+  }
+  /**
+   * Returns the value in the buffer at the provided location.
+   *
+   * @param locs The location indices.
+   *
+   * @doc {heading: 'Tensors', subheading: 'Creation'}
+   */
+  get(...t) {
+    t.length === 0 && (t = [0]);
+    let e = 0;
+    for (const r of t) {
+      if (r < 0 || r >= this.shape[e]) {
+        const i = `Requested out of range element at ${t}.   Buffer shape=${this.shape}`;
+        throw new Error(i);
+      }
+      e++;
+    }
+    let s = t[t.length - 1];
+    for (let r = 0; r < t.length - 1; ++r)
+      s += this.strides[r] * t[r];
+    return this.values[s];
+  }
+  locToIndex(t) {
+    if (this.rank === 0)
+      return 0;
+    if (this.rank === 1)
+      return t[0];
+    let e = t[t.length - 1];
+    for (let s = 0; s < t.length - 1; ++s)
+      e += this.strides[s] * t[s];
+    return e;
+  }
+  indexToLoc(t) {
+    if (this.rank === 0)
+      return [];
+    if (this.rank === 1)
+      return [t];
+    const e = new Array(this.shape.length);
+    for (let s = 0; s < e.length - 1; ++s)
+      e[s] = Math.floor(t / this.strides[s]), t -= e[s] * this.strides[s];
+    return e[e.length - 1] = t, e;
+  }
+  get rank() {
+    return this.shape.length;
+  }
+  /**
+   * Creates an immutable `tf.Tensor` object from the buffer.
+   *
+   * @doc {heading: 'Tensors', subheading: 'Creation'}
+   */
+  toTensor() {
+    return x().makeTensor(this.values, this.shape, this.dtype);
+  }
+}
+let x = null, J = null;
+function nn(n) {
+  x = n;
+}
+function sn(n) {
+  J = n;
+}
+class N {
+  constructor(t, e, s, r) {
+    this.kept = !1, this.isDisposedInternal = !1, this.shape = t.slice(), this.dtype = e || "float32", this.size = U(t), this.strides = Ft(t), this.dataId = s, this.id = r, this.rankType = this.rank < 5 ? this.rank.toString() : "higher";
+  }
+  get rank() {
+    return this.shape.length;
+  }
+  /**
+   * Returns a promise of `tf.TensorBuffer` that holds the underlying data.
+   *
+   * @doc {heading: 'Tensors', subheading: 'Classes'}
+   */
+  async buffer() {
+    const t = await this.data();
+    return J.buffer(this.shape, this.dtype, t);
+  }
+  /**
+   * Returns a `tf.TensorBuffer` that holds the underlying data.
+   * @doc {heading: 'Tensors', subheading: 'Classes'}
+   */
+  bufferSync() {
+    return J.buffer(this.shape, this.dtype, this.dataSync());
+  }
+  /**
+   * Returns the tensor data as a nested array. The transfer of data is done
+   * asynchronously.
+   *
+   * @doc {heading: 'Tensors', subheading: 'Classes'}
+   */
+  async array() {
+    const t = await this.data();
+    return Dt(this.shape, t, this.dtype === "complex64");
+  }
+  /**
+   * Returns the tensor data as a nested array. The transfer of data is done
+   * synchronously.
+   *
+   * @doc {heading: 'Tensors', subheading: 'Classes'}
+   */
+  arraySync() {
+    return Dt(this.shape, this.dataSync(), this.dtype === "complex64");
+  }
+  /**
+   * Asynchronously downloads the values from the `tf.Tensor`. Returns a
+   * promise of `TypedArray` that resolves when the computation has finished.
+   *
+   * @doc {heading: 'Tensors', subheading: 'Classes'}
+   */
+  async data() {
+    this.throwIfDisposed();
+    const t = x().read(this.dataId);
+    if (this.dtype === "string") {
+      const e = await t;
+      try {
+        return e.map((s) => Lt(s));
+      } catch {
+        throw new Error("Failed to decode the string bytes into utf-8. To get the original bytes, call tensor.bytes().");
+      }
+    }
+    return t;
+  }
+  /**
+   * Copy the tensor's data to a new GPU resource. Comparing to the `dataSync()`
+   * and `data()`, this method prevents data from being downloaded to CPU.
+   *
+   * For WebGL backend, the data will be stored on a densely packed texture.
+   * This means that the texture will use the RGBA channels to store value.
+   *
+   * For WebGPU backend, the data will be stored on a buffer. There is no
+   * parameter, so can not use a user-defined size to create the buffer.
+   *
+   * @param options:
+   *     For WebGL,
+   *         - customTexShape: Optional. If set, will use the user defined
+   *     texture shape to create the texture.
+   *
+   * @returns For WebGL backend, a GPUData contains the new texture and
+   *     its information.
+   *     {
+   *        tensorRef: The tensor that is associated with this texture,
+   *        texture: WebGLTexture,
+   *        texShape: [number, number] // [height, width]
+   *     }
+   *
+   *     For WebGPU backend, a GPUData contains the new buffer.
+   *     {
+   *        tensorRef: The tensor that is associated with this buffer,
+   *        buffer: GPUBuffer,
+   *     }
+   *
+   *     Remember to dispose the GPUData after it is used by
+   *     `res.tensorRef.dispose()`.
+   *
+   * @doc {heading: 'Tensors', subheading: 'Classes'}
+   */
+  dataToGPU(t) {
+    return this.throwIfDisposed(), x().readToGPU(this.dataId, t);
+  }
+  /**
+   * Synchronously downloads the values from the `tf.Tensor`. This blocks the
+   * UI thread until the values are ready, which can cause performance issues.
+   *
+   * @doc {heading: 'Tensors', subheading: 'Classes'}
+   */
+  dataSync() {
+    this.throwIfDisposed();
+    const t = x().readSync(this.dataId);
+    if (this.dtype === "string")
+      try {
+        return t.map((e) => Lt(e));
+      } catch {
+        throw new Error("Failed to decode the string bytes into utf-8. To get the original bytes, call tensor.bytes().");
+      }
+    return t;
+  }
+  /** Returns the underlying bytes of the tensor's data. */
+  async bytes() {
+    this.throwIfDisposed();
+    const t = await x().read(this.dataId);
+    return this.dtype === "string" ? t : new Uint8Array(t.buffer);
+  }
+  /**
+   * Disposes `tf.Tensor` from memory.
+   *
+   * @doc {heading: 'Tensors', subheading: 'Classes'}
+   */
+  dispose() {
+    this.isDisposed || (this.kerasMask && this.kerasMask.dispose(), x().disposeTensor(this), this.isDisposedInternal = !0);
+  }
+  get isDisposed() {
+    return this.isDisposedInternal;
+  }
+  throwIfDisposed() {
+    if (this.isDisposed)
+      throw new Error("Tensor is disposed.");
+  }
+  /**
+   * Prints the `tf.Tensor`. See `tf.print` for details.
+   *
+   * @param verbose Whether to print verbose information about the tensor,
+   *    including dtype and size.
+   *
+   * @doc {heading: 'Tensors', subheading: 'Classes'}
+   */
+  print(t = !1) {
+    return J.print(this, t);
+  }
+  /**
+   * Returns a copy of the tensor. See `tf.clone` for details.
+   * @doc {heading: 'Tensors', subheading: 'Classes'}
+   */
+  clone() {
+    return this.throwIfDisposed(), J.clone(this);
+  }
+  /**
+   * Returns a human-readable description of the tensor. Useful for logging.
+   *
+   * @doc {heading: 'Tensors', subheading: 'Classes'}
+   */
+  toString(t = !1) {
+    const e = this.dataSync();
+    return Ze(e, this.shape, this.dtype, t);
+  }
+  cast(t) {
+    return this.throwIfDisposed(), J.cast(this, t);
+  }
+  variable(t = !0, e, s) {
+    return this.throwIfDisposed(), x().makeVariable(this, t, e, s);
+  }
+}
+Object.defineProperty(N, Symbol.hasInstance, {
+  value: (n) => !!n && n.data != null && n.dataSync != null && n.throwIfDisposed != null
+});
+function re() {
+  return Nt("Tensor", () => N);
+}
+re();
+class ht extends N {
+  constructor(t, e, s, r) {
+    super(t.shape, t.dtype, t.dataId, r), this.trainable = e, this.name = s;
+  }
+  /**
+   * Assign a new `tf.Tensor` to this variable. The new `tf.Tensor` must have
+   * the same shape and dtype as the old `tf.Tensor`.
+   *
+   * @param newValue New tensor to be assigned to this variable.
+   *
+   * @doc {heading: 'Tensors', subheading: 'Classes'}
+   */
+  assign(t) {
+    if (t.dtype !== this.dtype)
+      throw new Error(`dtype of the new value (${t.dtype}) and previous value (${this.dtype}) must match`);
+    if (!vt(t.shape, this.shape))
+      throw new Error(`shape of the new value (${t.shape}) and previous value (${this.shape}) must match`);
+    x().disposeTensor(this), this.dataId = t.dataId, x().incRef(
+      this,
+      null
+      /* backend */
+    );
+  }
+  dispose() {
+    x().disposeVariable(this), this.isDisposedInternal = !0;
+  }
+}
+Object.defineProperty(ht, Symbol.hasInstance, {
+  value: (n) => n instanceof N && n.assign != null && n.assign instanceof Function
+});
+/**
+ * @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 Gt;
+(function(n) {
+  n.R0 = "R0", n.R1 = "R1", n.R2 = "R2", n.R3 = "R3", n.R4 = "R4", n.R5 = "R5", n.R6 = "R6";
+})(Gt || (Gt = {}));
+var wt;
+(function(n) {
+  n.float32 = "float32", n.int32 = "int32", n.bool = "int32", n.complex64 = "complex64";
+})(wt || (wt = {}));
+var St;
+(function(n) {
+  n.float32 = "float32", n.int32 = "int32", n.bool = "bool", n.complex64 = "complex64";
+})(St || (St = {}));
+var It;
+(function(n) {
+  n.float32 = "float32", n.int32 = "float32", n.bool = "float32", n.complex64 = "complex64";
+})(It || (It = {}));
+var kt;
+(function(n) {
+  n.float32 = "complex64", n.int32 = "complex64", n.bool = "complex64", n.complex64 = "complex64";
+})(kt || (kt = {}));
+const rn = {
+  float32: It,
+  int32: wt,
+  bool: St,
+  complex64: kt
+};
+function on(n, t) {
+  if (n === "string" || t === "string") {
+    if (n === "string" && t === "string")
+      return "string";
+    throw new Error(`Can not upcast ${n} with ${t}`);
+  }
+  return rn[n][t];
+}
+function ie(n) {
+  return n != null && typeof n == "object" && "texture" in n && n.texture instanceof WebGLTexture;
+}
+function oe(n) {
+  return typeof GPUBuffer < "u" && n != null && typeof n == "object" && "buffer" in n && n.buffer instanceof GPUBuffer;
+}
+/**
+ * @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 K(n, t) {
+  if (n.dtype === t.dtype)
+    return [n, t];
+  const e = on(n.dtype, t.dtype);
+  return [n.cast(e), t.cast(e)];
+}
+function ae(n) {
+  const t = [];
+  return le(n, t, /* @__PURE__ */ new Set()), t;
+}
+function le(n, t, e) {
+  if (n == null)
+    return;
+  if (n instanceof N) {
+    t.push(n);
+    return;
+  }
+  if (!an(n))
+    return;
+  const s = n;
+  for (const r in s) {
+    const i = s[r];
+    e.has(i) || (e.add(i), le(i, t, e));
+  }
+}
+function an(n) {
+  return Array.isArray(n) || typeof n == "object";
+}
+/**
+ * @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 mt(n) {
+  return n.kernelName != null;
+}
+class zt {
+  constructor() {
+    this.registeredVariables = {}, this.nextTapeNodeId = 0, this.numBytes = 0, this.numTensors = 0, this.numStringTensors = 0, this.numDataBuffers = 0, this.gradientDepth = 0, this.kernelDepth = 0, this.scopeStack = [], this.numDataMovesStack = [], this.nextScopeId = 0, this.tensorInfo = /* @__PURE__ */ new WeakMap(), this.profiling = !1, this.activeProfile = {
+      newBytes: 0,
+      newTensors: 0,
+      peakBytes: 0,
+      kernels: [],
+      result: null,
+      get kernelNames() {
+        return Array.from(new Set(this.kernels.map((t) => t.name)));
+      }
+    };
+  }
+  dispose() {
+    for (const t in this.registeredVariables)
+      this.registeredVariables[t].dispose();
+  }
+}
+class Q {
+  constructor(t) {
+    this.ENV = t, this.registry = {}, this.registryFactory = {}, this.pendingBackendInitId = 0, this.state = new zt();
+  }
+  async ready() {
+    if (this.pendingBackendInit != null)
+      return this.pendingBackendInit.then(() => {
+      });
+    if (this.backendInstance != null)
+      return;
+    const t = this.getSortedBackends();
+    for (let e = 0; e < t.length; e++) {
+      const s = t[e];
+      if (await this.initializeBackend(s).success) {
+        await this.setBackend(s);
+        return;
+      }
+    }
+    throw new Error("Could not initialize any backends, all backend initializations failed.");
+  }
+  get backend() {
+    if (this.pendingBackendInit != null)
+      throw new Error(`Backend '${this.backendName}' has not yet been initialized. Make sure to await tf.ready() or await tf.setBackend() before calling other methods`);
+    if (this.backendInstance == null) {
+      const { name: t, asyncInit: e } = this.initializeBackendsAndReturnBest();
+      if (e)
+        throw new Error(`The highest priority backend '${t}' has not yet been initialized. Make sure to await tf.ready() or await tf.setBackend() before calling other methods`);
+      this.setBackend(t);
+    }
+    return this.backendInstance;
+  }
+  backendNames() {
+    return Object.keys(this.registryFactory);
+  }
+  findBackend(t) {
+    if (!(t in this.registry))
+      if (t in this.registryFactory) {
+        const { asyncInit: e } = this.initializeBackend(t);
+        if (e)
+          return null;
+      } else
+        return null;
+    return this.registry[t];
+  }
+  findBackendFactory(t) {
+    return t in this.registryFactory ? this.registryFactory[t].factory : null;
+  }
+  registerBackend(t, e, s = 1) {
+    return t in this.registryFactory ? (nt(`${t} backend was already registered. Reusing existing backend factory.`), !1) : (this.registryFactory[t] = { factory: e, priority: s }, !0);
+  }
+  async setBackend(t) {
+    if (this.registryFactory[t] == null)
+      throw new Error(`Backend name '${t}' not found in registry`);
+    if (this.backendName = t, this.registry[t] == null) {
+      this.backendInstance = null;
+      const { success: e, asyncInit: s } = this.initializeBackend(t);
+      if (!(s ? await e : e))
+        return !1;
+    }
+    return this.backendInstance = this.registry[t], this.setupRegisteredKernels(), this.profiler = new He(this.backendInstance), !0;
+  }
+  setupRegisteredKernels() {
+    Pt(this.backendName).forEach((e) => {
+      e.setupFunc != null && e.setupFunc(this.backendInstance);
+    });
+  }
+  disposeRegisteredKernels(t) {
+    Pt(t).forEach((s) => {
+      s.disposeFunc != null && s.disposeFunc(this.registry[t]);
+    });
+  }
+  /**
+   * Initializes a backend by looking up the backend name in the factory
+   * registry and calling the factory method. Returns a boolean representing
+   * whether the initialization of the backend succeeded. Throws an error if
+   * there is no backend in the factory registry.
+   */
+  initializeBackend(t) {
+    const e = this.registryFactory[t];
+    if (e == null)
+      throw new Error(`Cannot initialize backend ${t}, no registration found.`);
+    try {
+      const s = e.factory();
+      if (s && !(s instanceof we) && typeof s.then == "function") {
+        const r = ++this.pendingBackendInitId, i = s.then((o) => r < this.pendingBackendInitId ? !1 : (this.registry[t] = o, this.pendingBackendInit = null, !0)).catch((o) => (r < this.pendingBackendInitId || (this.pendingBackendInit = null, nt(`Initialization of backend ${t} failed`), nt(o.stack || o.message)), !1));
+        return this.pendingBackendInit = i, { success: i, asyncInit: !0 };
+      } else
+        return this.registry[t] = s, { success: !0, asyncInit: !1 };
+    } catch (s) {
+      return nt(`Initialization of backend ${t} failed`), nt(s.stack || s.message), { success: !1, asyncInit: !1 };
+    }
+  }
+  removeBackend(t) {
+    if (!(t in this.registryFactory))
+      throw new Error(`${t} backend not found in registry`);
+    this.backendName === t && this.pendingBackendInit != null && this.pendingBackendInitId++, t in this.registry && (this.disposeRegisteredKernels(t), this.registry[t].dispose(), delete this.registry[t]), delete this.registryFactory[t], this.backendName === t && (this.pendingBackendInit = null, this.backendName = null, this.backendInstance = null);
+  }
+  getSortedBackends() {
+    if (Object.keys(this.registryFactory).length === 0)
+      throw new Error("No backend found in registry.");
+    return Object.keys(this.registryFactory).sort((t, e) => this.registryFactory[e].priority - this.registryFactory[t].priority);
+  }
+  initializeBackendsAndReturnBest() {
+    const t = this.getSortedBackends();
+    for (let e = 0; e < t.length; e++) {
+      const s = t[e], { success: r, asyncInit: i } = this.initializeBackend(s);
+      if (i || r)
+        return { name: s, asyncInit: i };
+    }
+    throw new Error("Could not initialize any backends, all backend initializations failed.");
+  }
+  moveData(t, e) {
+    const s = this.state.tensorInfo.get(e), r = s.backend, i = this.readSync(e), o = r.refCount(e);
+    r.disposeData(e, !0), s.backend = t, t.move(e, i, s.shape, s.dtype, o), this.shouldCheckForMemLeaks() && this.state.numDataMovesStack[this.state.numDataMovesStack.length - 1]++;
+  }
+  tidy(t, e) {
+    let s = null;
+    if (e == null) {
+      if (typeof t != "function")
+        throw new Error("Please provide a function to tidy()");
+      e = t;
+    } else {
+      if (typeof t != "string" && !(t instanceof String))
+        throw new Error("When calling with two arguments, the first argument to tidy() must be a string");
+      if (typeof e != "function")
+        throw new Error("When calling with two arguments, the 2nd argument to tidy() must be a function");
+      s = t;
+    }
+    let r;
+    return this.scopedRun(() => this.startScope(s), () => this.endScope(r), () => (r = e(), r instanceof Promise && console.error("Cannot return a Promise inside of tidy."), r));
+  }
+  scopedRun(t, e, s) {
+    t();
+    try {
+      const r = s();
+      return e(), r;
+    } catch (r) {
+      throw e(), r;
+    }
+  }
+  nextTensorId() {
+    return Q.nextTensorId++;
+  }
+  nextVariableId() {
+    return Q.nextVariableId++;
+  }
+  /**
+   * This method is called instead of the public-facing tensor.clone() when
+   * saving a tensor for backwards pass. It makes sure to add the clone
+   * operation to the tape regardless of being called inside a kernel
+   * execution.
+   */
+  clone(t) {
+    const e = g.runKernel(Zt, { x: t }), s = { x: t }, r = (o) => ({
+      x: () => {
+        const a = "float32", c = { x: o }, l = { dtype: a };
+        return g.runKernel(
+          Qt,
+          c,
+          // tslint:disable-next-line: no-unnecessary-type-assertion
+          l
+        );
+      }
+    }), i = [];
+    return this.addTapeNode(this.state.activeScope.name, s, [e], r, i, {}), e;
+  }
+  /**
+   * Execute a kernel with the given name and return the output tensor.
+   *
+   * @param kernelName The name of the kernel to execute.
+   * @param inputs A map of input names to tensors.
+   * @param attrs A map of attribute names to their values. An attribute is a
+   *     primitive (non-tensor) input to the kernel.
+   * @param inputsToSave A list of tensors, inputs to save for the backprop
+   *     computation.
+   * @param outputsToSave A list of booleans, specifying which output to save
+   *     for the backprop computation. These are booleans since the output
+   * tensors are not visible to the user.
+   */
+  runKernel(t, e, s) {
+    if (this.backendName == null && this.backend, !(_t(t, this.backendName) != null))
+      throw new Error(`Kernel '${t}' not registered for backend '${this.backendName}'`);
+    return this.runKernelFunc({ kernelName: t, inputs: e, attrs: s });
+  }
+  shouldCheckForMemLeaks() {
+    return this.ENV.getBool("IS_TEST");
+  }
+  checkKernelForMemLeak(t, e, s) {
+    const r = this.backend.numDataIds();
+    let i = 0;
+    s.forEach((c) => {
+      i += c.dtype === "complex64" ? 3 : 1;
+    });
+    const o = this.state.numDataMovesStack[this.state.numDataMovesStack.length - 1], a = r - e - i - o;
+    if (a > 0)
+      throw new Error(`Backend '${this.backendName}' has an internal memory leak (${a} data ids) after running '${t}'`);
+  }
+  /**
+   * Internal helper method to execute a kernel Func
+   *
+   * Use `runKernel` to execute kernels from outside of engine.
+   */
+  runKernelFunc(t) {
+    let e, s = [];
+    const r = this.isTapeOn(), i = this.state.numBytes, o = this.state.numTensors;
+    this.shouldCheckForMemLeaks() && this.state.numDataMovesStack.push(0);
+    let a;
+    this.backendName == null && this.backend;
+    let c;
+    const l = mt(t) ? t.kernelName : this.state.activeScope != null ? this.state.activeScope.name : "";
+    if (mt(t)) {
+      const { kernelName: y, inputs: d, attrs: I } = t;
+      this.backendName == null && this.backend;
+      const T = _t(y, this.backendName);
+      b(T != null, () => `Cannot find registered kernel '${y}' for backend '${this.backendName}'`), a = () => {
+        const tt = this.backend.numDataIds();
+        c = T.kernelFunc({ inputs: d, attrs: I, backend: this.backend });
+        const q = Array.isArray(c) ? c : [c];
+        this.shouldCheckForMemLeaks() && this.checkKernelForMemLeak(y, tt, q);
+        const H = q.map((et) => et.rank != null ? et : this.makeTensorFromTensorInfo(et));
+        if (r) {
+          const et = this.getTensorsForGradient(y, d, H);
+          s = this.saveTensorsForBackwardMode(et);
+        }
+        return H;
+      };
+    } else {
+      const { forwardFunc: y } = t, d = (I) => {
+        r && (s = I.map((T) => this.keep(this.clone(T))));
+      };
+      a = () => {
+        const I = this.backend.numDataIds();
+        c = this.tidy(() => y(this.backend, d));
+        const T = Array.isArray(c) ? c : [c];
+        return this.shouldCheckForMemLeaks() && this.checkKernelForMemLeak(l, I, T), T;
+      };
+    }
+    const { inputs: u, attrs: h } = t, f = mt(t) ? null : t.backwardsFunc;
+    let m;
+    return this.scopedRun(
+      // Stop recording to a tape when running a kernel.
+      () => this.state.kernelDepth++,
+      () => this.state.kernelDepth--,
+      () => {
+        !this.ENV.getBool("DEBUG") && !this.state.profiling ? e = a() : (m = this.profiler.profileKernel(l, u, () => a()), this.ENV.getBool("DEBUG") && this.profiler.logKernelProfile(m), e = m.outputs);
+      }
+    ), r && this.addTapeNode(l, u, e, f, s, h), this.state.profiling && this.state.activeProfile.kernels.push({
+      name: l,
+      bytesAdded: this.state.numBytes - i,
+      totalBytesSnapshot: this.state.numBytes,
+      tensorsAdded: this.state.numTensors - o,
+      totalTensorsSnapshot: this.state.numTensors,
+      inputShapes: Object.keys(u).map((y) => u[y] != null ? u[y].shape : null),
+      outputShapes: e.map((y) => y.shape),
+      kernelTimeMs: m.timeMs,
+      extraInfo: m.extraInfo
+    }), Array.isArray(c) ? e : e[0];
+  }
+  /**
+   * Saves tensors used in forward mode for use in backward mode.
+   *
+   * @param tensors the list of tensors to save.
+   */
+  saveTensorsForBackwardMode(t) {
+    return t.map((s) => this.keep(this.clone(s)));
+  }
+  /**
+   * Returns a list of tensors to save for a given gradient calculation.
+   *
+   * @param kernelName name of kernel to look up gradient for.
+   * @param inputs a map of input tensors.
+   * @param outputs an array of output tensors from forward mode of kernel.
+   */
+  getTensorsForGradient(t, e, s) {
+    const r = Ot(t);
+    if (r != null) {
+      const i = r.inputsToSave || [], o = r.outputsToSave || [];
+      let a;
+      r.saveAllInputs ? (b(Array.isArray(e), () => "saveAllInputs is true, expected inputs to be an array."), a = Object.keys(e).map((l) => e[l])) : a = i.map((l) => e[l]);
+      const c = s.filter((l, u) => o[u]);
+      return a.concat(c);
+    }
+    return [];
+  }
+  /**
+   * Internal method used by public APIs for tensor creation. Makes a new
+   * tensor with the provided shape, dtype and values. It always
+   * creates a new data id and writes the values to the underlying backend.
+   */
+  makeTensor(t, e, s, r) {
+    if (t == null)
+      throw new Error("Values passed to engine.makeTensor() are null");
+    s = s || "float32", r = r || this.backend;
+    let i = t;
+    s === "string" && Mt(t[0]) && (i = t.map((c) => qe(c)));
+    const o = r.write(i, e, s), a = new N(e, s, o, this.nextTensorId());
+    if (this.trackTensor(a, r), s === "string") {
+      const c = this.state.tensorInfo.get(o), l = Te(i);
+      this.state.numBytes += l - c.bytes, c.bytes = l;
+    }
+    return a;
+  }
+  /**
+   * Internal method used by backends. Makes a new tensor
+   * that is a wrapper around an existing data id. It doesn't create
+   * a new data id, only increments the ref count used in memory tracking.
+   * @deprecated
+   */
+  makeTensorFromDataId(t, e, s, r) {
+    s = s || "float32";
+    const i = { dataId: t, shape: e, dtype: s };
+    return this.makeTensorFromTensorInfo(i, r);
+  }
+  /**
+   * Internal method used by backends. Makes a new tensor that is a wrapper
+   * around an existing data id in TensorInfo. It doesn't create a new data id,
+   * only increments the ref count used in memory tracking.
+   */
+  makeTensorFromTensorInfo(t, e) {
+    const { dataId: s, shape: r, dtype: i } = t, o = new N(r, i, s, this.nextTensorId());
+    return this.trackTensor(o, e), o;
+  }
+  makeVariable(t, e = !0, s, r) {
+    s = s || this.nextVariableId().toString(), r != null && r !== t.dtype && (t = t.cast(r));
+    const i = new ht(t, e, s, this.nextTensorId());
+    if (this.state.registeredVariables[i.name] != null)
+      throw new Error(`Variable with name ${i.name} was already registered`);
+    return this.state.registeredVariables[i.name] = i, this.incRef(i, this.backend), i;
+  }
+  trackTensor(t, e) {
+    this.state.numTensors++, t.dtype === "string" && this.state.numStringTensors++;
+    let s = 0;
+    t.dtype !== "complex64" && t.dtype !== "string" && (s = t.size * yt(t.dtype)), this.state.numBytes += s, this.state.tensorInfo.has(t.dataId) || (this.state.numDataBuffers++, this.state.tensorInfo.set(t.dataId, {
+      backend: e || this.backend,
+      dtype: t.dtype,
+      shape: t.shape,
+      bytes: s
+    })), t instanceof ht || this.track(t);
+  }
+  // Track the tensor by dataId and increase the refCount for the dataId in the
+  // backend.
+  // TODO(pyu10055): This is currently used by makeVariable method, to increase
+  // refCount on the backend for the dataId. It can potentially be replaced with
+  // Identity op indead of calling backend directly.
+  incRef(t, e) {
+    this.trackTensor(t, e), this.backend.incRef(t.dataId);
+  }
+  removeDataId(t, e) {
+    this.state.tensorInfo.has(t) && this.state.tensorInfo.get(t).backend === e && (this.state.tensorInfo.delete(t), this.state.numDataBuffers--);
+  }
+  disposeTensor(t) {
+    if (!this.state.tensorInfo.has(t.dataId))
+      return;
+    const e = this.state.tensorInfo.get(t.dataId);
+    if (this.state.numTensors--, t.dtype === "string" && (this.state.numStringTensors--, this.state.numBytes -= e.bytes), t.dtype !== "complex64" && t.dtype !== "string") {
+      const s = t.size * yt(t.dtype);
+      this.state.numBytes -= s;
+    }
+    e.backend.disposeData(t.dataId) && this.removeDataId(t.dataId, e.backend);
+  }
+  disposeVariables() {
+    for (const t in this.state.registeredVariables) {
+      const e = this.state.registeredVariables[t];
+      this.disposeVariable(e);
+    }
+  }
+  disposeVariable(t) {
+    this.disposeTensor(t), this.state.registeredVariables[t.name] != null && delete this.state.registeredVariables[t.name];
+  }
+  memory() {
+    const t = this.backend.memory();
+    return t.numTensors = this.state.numTensors, t.numDataBuffers = this.state.numDataBuffers, t.numBytes = this.state.numBytes, this.state.numStringTensors > 0 && (t.unreliable = !0, t.reasons == null && (t.reasons = []), t.reasons.push("Memory usage by string tensors is approximate (2 bytes per character)")), t;
+  }
+  async profile(t) {
+    this.state.profiling = !0;
+    const e = this.state.numBytes, s = this.state.numTensors;
+    this.state.activeProfile.kernels = [], this.state.activeProfile.result = await t(), this.state.profiling = !1, this.state.activeProfile.peakBytes = Math.max(...this.state.activeProfile.kernels.map((r) => r.totalBytesSnapshot)), this.state.activeProfile.newBytes = this.state.numBytes - e, this.state.activeProfile.newTensors = this.state.numTensors - s;
+    for (const r of this.state.activeProfile.kernels)
+      r.kernelTimeMs = await r.kernelTimeMs, r.extraInfo = await r.extraInfo;
+    return this.state.activeProfile;
+  }
+  isTapeOn() {
+    return this.state.gradientDepth > 0 && this.state.kernelDepth === 0;
+  }
+  addTapeNode(t, e, s, r, i, o) {
+    const a = { id: this.state.nextTapeNodeId++, kernelName: t, inputs: e, outputs: s, saved: i }, c = Ot(t);
+    c != null && (r = c.gradFunc), r != null && (a.gradient = (l) => (l = l.map((u, h) => {
+      if (u == null) {
+        const f = s[h], m = Ht(f.size, f.dtype);
+        return this.makeTensor(m, f.shape, f.dtype);
+      }
+      return u;
+    }), r(l.length > 1 ? l : l[0], i, o))), this.state.activeTape.push(a);
+  }
+  keep(t) {
+    return t.kept = !0, t;
+  }
+  startTape() {
+    this.state.gradientDepth === 0 && (this.state.activeTape = []), this.state.gradientDepth++;
+  }
+  endTape() {
+    this.state.gradientDepth--;
+  }
+  /**
+   * Start a scope. Use this with endScope() to achieve the same functionality
+   * as scope() without the need for a function closure.
+   */
+  startScope(t) {
+    const e = {
+      track: [],
+      name: "unnamed scope",
+      id: this.state.nextScopeId++
+    };
+    t && (e.name = t), this.state.scopeStack.push(e), this.state.activeScope = e;
+  }
+  /**
+   * End a scope. Use this with startScope() to achieve the same functionality
+   * as scope() without the need for a function closure.
+   */
+  endScope(t) {
+    const e = ae(t), s = new Set(e.map((i) => i.id));
+    for (let i = 0; i < this.state.activeScope.track.length; i++) {
+      const o = this.state.activeScope.track[i];
+      !o.kept && !s.has(o.id) && o.dispose();
+    }
+    const r = this.state.scopeStack.pop();
+    this.state.activeScope = this.state.scopeStack.length === 0 ? null : this.state.scopeStack[this.state.scopeStack.length - 1], e.forEach((i) => {
+      !i.kept && i.scopeId === r.id && this.track(i);
+    });
+  }
+  /**
+   * Returns gradients of `f` with respect to each of the `xs`. The gradients
+   * returned are of the same length as `xs`, but some might be null if `f`
+   * was not a function of that `x`. It also takes optional dy to multiply the
+   * gradient, which defaults to `1`.
+   */
+  gradients(t, e, s, r = !1) {
+    if (b(e.length > 0, () => "gradients() received an empty list of xs."), s != null && s.dtype !== "float32")
+      throw new Error(`dy must have 'float32' dtype, but has '${s.dtype}'`);
+    const i = this.scopedRun(() => this.startTape(), () => this.endTape(), () => this.tidy("forward", t));
+    b(i instanceof N, () => "The result y returned by f() must be a tensor.");
+    const o = Ye(this.state.activeTape, e, i);
+    if (!r && o.length === 0 && e.length > 0)
+      throw new Error("Cannot compute gradient of y=f(x) with respect to x. Make sure that the f you passed encloses all operations that lead from x to y.");
+    return this.tidy("backward", () => {
+      const a = {};
+      a[i.id] = s ?? ln(i.shape), Qe(
+        a,
+        o,
+        // Pass the tidy function to avoid circular dep with `tape.ts`.
+        (l) => this.tidy(l),
+        // Pass an add function to avoide a circular dep with `tape.ts`.
+        cn
+      );
+      const c = e.map((l) => a[l.id]);
+      return this.state.gradientDepth === 0 && (this.state.activeTape.forEach((l) => {
+        for (const u of l.saved)
+          u.dispose();
+      }), this.state.activeTape = null), { value: i, grads: c };
+    });
+  }
+  customGrad(t) {
+    return b(bt(t), () => "The f passed in customGrad(f) must be a function."), (...e) => {
+      b(e.every((a) => a instanceof N), () => "The args passed in customGrad(f)(x1, x2,...) must all be tensors");
+      let s;
+      const r = {};
+      e.forEach((a, c) => {
+        r[c] = a;
+      });
+      const i = (a, c) => (s = t(...e, c), b(s.value instanceof N, () => "The function f passed in customGrad(f) must return an object where `obj.value` is a tensor"), b(bt(s.gradFunc), () => "The function f passed in customGrad(f) must return an object where `obj.gradFunc` is a function."), s.value), o = (a, c) => {
+        const l = s.gradFunc(a, c), u = Array.isArray(l) ? l : [l];
+        b(u.length === e.length, () => "The function f passed in customGrad(f) must return an object where `obj.gradFunc` is a function that returns the same number of tensors as inputs passed to f(...)."), b(u.every((f) => f instanceof N), () => "The function f passed in customGrad(f) must return an object where `obj.gradFunc` is a function that returns a list of only tensors.");
+        const h = {};
+        return u.forEach((f, m) => {
+          h[m] = () => f;
+        }), h;
+      };
+      return this.runKernelFunc({
+        forwardFunc: i,
+        backwardsFunc: o,
+        inputs: r
+      });
+    };
+  }
+  readSync(t) {
+    return this.state.tensorInfo.get(t).backend.readSync(t);
+  }
+  read(t) {
+    return this.state.tensorInfo.get(t).backend.read(t);
+  }
+  readToGPU(t, e) {
+    return this.state.tensorInfo.get(t).backend.readToGPU(t, e);
+  }
+  async time(t) {
+    const e = ut(), s = await this.backend.time(t);
+    return s.wallMs = ut() - e, s;
+  }
+  /**
+   * Tracks a Tensor in the current scope to be automatically cleaned up
+   * when the current scope ends, and returns the value.
+   *
+   * @param result The Tensor to track in the current scope.
+   */
+  track(t) {
+    return this.state.activeScope != null && (t.scopeId = this.state.activeScope.id, this.state.activeScope.track.push(t)), t;
+  }
+  get registeredVariables() {
+    return this.state.registeredVariables;
+  }
+  /**
+   * Resets the engine state. Removes all backends but does not remove
+   * registered backend factories.
+   */
+  reset() {
+    this.pendingBackendInitId++, this.state.dispose(), this.ENV.reset(), this.state = new zt();
+    for (const t in this.registry)
+      this.disposeRegisteredKernels(t), this.registry[t].dispose(), delete this.registry[t];
+    this.backendName = null, this.backendInstance = null, this.pendingBackendInit = null;
+  }
+}
+Q.nextTensorId = 0;
+Q.nextVariableId = 0;
+function ln(n) {
+  const t = Ae(U(n), "float32");
+  return g.makeTensor(t, n, "float32");
+}
+function ce() {
+  const n = Xt();
+  if (n._tfengine == null) {
+    const t = new ve(n);
+    n._tfengine = new Q(t);
+  }
+  return xe(n._tfengine.ENV), nn(() => n._tfengine), n._tfengine;
+}
+const g = ce();
+function cn(n, t) {
+  const e = { a: n, b: t };
+  return g.runKernel(Yt, e);
+}
+/**
+ * @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 un() {
+  return typeof window < "u" && window.document != null || //@ts-ignore
+  typeof WorkerGlobalScope < "u";
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+const A = S();
+A.registerFlag("DEBUG", () => !1, (n) => {
+  n && console.warn("Debugging mode is ON. The output of every math call will be downloaded to CPU and checked for NaNs. This significantly impacts performance.");
+});
+A.registerFlag("IS_BROWSER", () => un());
+A.registerFlag("IS_NODE", () => typeof process < "u" && typeof process.versions < "u" && typeof process.versions.node < "u");
+A.registerFlag("IS_CHROME", () => typeof navigator < "u" && navigator != null && navigator.userAgent != null && /Chrome/.test(navigator.userAgent) && /Google Inc/.test(navigator.vendor));
+A.registerFlag("IS_SAFARI", () => typeof navigator < "u" && navigator != null && navigator.userAgent != null && /Safari/.test(navigator.userAgent) && /Apple/.test(navigator.vendor));
+A.registerFlag("PROD", () => !1);
+A.registerFlag("TENSORLIKE_CHECK_SHAPE_CONSISTENCY", () => A.getBool("DEBUG"));
+A.registerFlag("DEPRECATION_WARNINGS_ENABLED", () => !0);
+A.registerFlag("IS_TEST", () => !1);
+A.registerFlag("CHECK_COMPUTATION_FOR_ERRORS", () => A.getBool("DEBUG"));
+A.registerFlag("WRAP_TO_IMAGEBITMAP", () => !1);
+A.registerFlag("CANVAS2D_WILL_READ_FREQUENTLY_FOR_GPU", () => !1);
+A.registerFlag("USE_SETTIMEOUTCUSTOM", () => !1);
+/**
+ * @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 hn(n, t) {
+  let e = n;
+  if (R(n))
+    return t === "string" ? [] : [n.length];
+  if (ie(n)) {
+    const r = n.channels || "RGBA";
+    return [n.height, n.width * r.length];
+  } else if (oe(n))
+    return [n.buffer.size / (t == null ? 4 : yt(t))];
+  if (!Array.isArray(n))
+    return [];
+  const s = [];
+  for (; Array.isArray(e) || R(e) && t !== "string"; )
+    s.push(e.length), e = e[0];
+  return Array.isArray(n) && S().getBool("TENSORLIKE_CHECK_SHAPE_CONSISTENCY") && ue(n, s, []), s;
+}
+function ue(n, t, e) {
+  if (e = e || [], !Array.isArray(n) && !R(n)) {
+    b(t.length === 0, () => `Element arr[${e.join("][")}] is a primitive, but should be an array/TypedArray of ${t[0]} elements`);
+    return;
+  }
+  b(t.length > 0, () => `Element arr[${e.join("][")}] should be a primitive, but is an array of ${n.length} elements`), b(n.length === t[0], () => `Element arr[${e.join("][")}] should have ${t[0]} elements, but has ${n.length} elements`);
+  const s = t.slice(1);
+  for (let r = 0; r < n.length; ++r)
+    ue(n[r], s, e.concat(r));
+}
+function Wt(n, t, e, s) {
+  if (n !== "string_or_numeric") {
+    if (n == null)
+      throw new Error("Expected dtype cannot be null.");
+    if (n !== "numeric" && n !== t || n === "numeric" && t === "string")
+      throw new Error(`Argument '${e}' passed to '${s}' must be ${n} tensor, but got ${t} tensor`);
+  }
+}
+function k(n, t, e, s = "numeric") {
+  if (n instanceof re())
+    return Wt(s, n.dtype, t, e), n;
+  let r = ft(n);
+  if (r !== "string" && ["bool", "int32", "float32"].indexOf(s) >= 0 && (r = s), Wt(s, r, t, e), n == null || !R(n) && !Array.isArray(n) && typeof n != "number" && typeof n != "boolean" && typeof n != "string") {
+    const c = n == null ? "null" : n.constructor.name;
+    throw new Error(`Argument '${t}' passed to '${e}' must be a Tensor or TensorLike, but got '${c}'`);
+  }
+  const i = hn(n, r);
+  !R(n) && !Array.isArray(n) && (n = [n]);
+  const a = r !== "string" ? ne(n, r) : ot(n, [], !0);
+  return g.makeTensor(a, i, 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 fn = "__op";
+function F(n) {
+  const t = Object.keys(n);
+  if (t.length !== 1)
+    throw new Error(`Please provide an object with a single key (operation name) mapping to a function. Got an object with ${t.length} keys.`);
+  let e = t[0];
+  const s = n[e];
+  e.endsWith("_") && (e = e.substring(0, e.length - 1)), e = e + fn;
+  const r = (...i) => {
+    g.startScope(e);
+    try {
+      const o = s(...i);
+      return xt(o) && console.error("Cannot return a Promise inside of tidy."), g.endScope(o), o;
+    } catch (o) {
+      throw g.endScope(null), o;
+    }
+  };
+  return Object.defineProperty(r, "name", { value: e, configurable: !0 }), 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.
+ * =============================================================================
+ */
+function dn(n, t, e, s) {
+  if (s == null)
+    s = ft(n);
+  else if (s === "complex64")
+    throw new Error("Cannot construct a complex64 tensor directly. Please use tf.complex(real, imag).");
+  if (oe(n) || ie(n)) {
+    if (s !== "float32" && s !== "int32")
+      throw new Error(`Creating tensor from GPU data only supports 'float32'|'int32' dtype, while the dtype is ${s}.`);
+    return g.backend.createTensorFromGPUData(n, t || e, s);
+  }
+  if (!R(n) && !Array.isArray(n) && typeof n != "number" && typeof n != "boolean" && typeof n != "string")
+    throw new Error("values passed to tensor(values) must be a number/boolean/string or an array of numbers/booleans/strings, or a TypedArray");
+  if (t != null) {
+    Rt(t);
+    const r = U(t), i = U(e);
+    b(r === i, () => `Based on the provided shape, [${t}], the tensor should have ${r} values but has ${i}`);
+    for (let o = 0; o < e.length; ++o) {
+      const a = e[o], c = o === e.length - 1 ? a !== U(t.slice(o)) : !0;
+      b(e[o] === t[o] || !c, () => `Error creating a new Tensor. Inferred shape (${e}) does not match the provided shape (${t}). `);
+    }
+  }
+  return !R(n) && !Array.isArray(n) && (n = [n]), t = t || e, n = s !== "string" ? ne(n, s) : ot(n, [], !0), g.makeTensor(n, t, s);
+}
+class at {
+  /**
+   * Concatenate a number of ArrayBuffers into one.
+   *
+   * @param buffers An array of ArrayBuffers to concatenate, or a single
+   *     ArrayBuffer.
+   * @returns Result of concatenating `buffers` in order.
+   */
+  static join(t) {
+    return new at(t).slice();
+  }
+  constructor(t) {
+    if (this.shards = [], this.previousShardIndex = 0, t == null || (t instanceof Array || (t = [t]), t = t.map((s) => R(s) ? s.buffer : s), t.length === 0))
+      return;
+    this.bufferUniformSize = t[0].byteLength;
+    let e = 0;
+    for (let s = 0; s < t.length; s++) {
+      const r = t[s];
+      s !== t.length - 1 && r.byteLength !== this.bufferUniformSize && (this.bufferUniformSize = void 0);
+      const i = e + r.byteLength;
+      this.shards.push({ buffer: r, start: e, end: i }), e = i;
+    }
+    this.shards.length === 0 && (this.byteLength = 0), this.byteLength = this.shards[this.shards.length - 1].end;
+  }
+  slice(t = 0, e = this.byteLength) {
+    if (this.shards.length === 0)
+      return new ArrayBuffer(0);
+    if (t = isNaN(Number(t)) ? 0 : t, e = isNaN(Number(e)) ? 0 : e, t = Math.max(0, t), e = Math.min(this.byteLength, e), e <= t)
+      return new ArrayBuffer(0);
+    const s = this.findShardForByte(t);
+    if (s === -1)
+      throw new Error(`Could not find start shard for byte ${t}`);
+    const r = e - t, i = new ArrayBuffer(r), o = new Uint8Array(i);
+    let a = 0;
+    for (let c = s; c < this.shards.length; c++) {
+      const l = this.shards[c], h = t + a - l.start, f = a, y = Math.min(e, l.end) - l.start, d = new Uint8Array(l.buffer, h, y - h);
+      if (o.set(d, f), a += d.length, e < l.end)
+        break;
+    }
+    return i;
+  }
+  /**
+   * Get the index of the shard that contains the byte at `byteIndex`.
+   */
+  findShardForByte(t) {
+    if (this.shards.length === 0 || t < 0 || t >= this.byteLength)
+      return -1;
+    if (this.bufferUniformSize != null)
+      return this.previousShardIndex = Math.floor(t / this.bufferUniformSize), this.previousShardIndex;
+    function e(r) {
+      return t < r.start ? -1 : t >= r.end ? 1 : 0;
+    }
+    if (e(this.shards[this.previousShardIndex]) === 0)
+      return this.previousShardIndex;
+    const s = gn(this.shards, e);
+    return s === -1 ? -1 : (this.previousShardIndex = s, this.previousShardIndex);
+  }
+}
+function gn(n, t) {
+  let e = 0, s = n.length;
+  for (; e <= s; ) {
+    const r = Math.floor((s - e) / 2) + e, i = t(n[r]);
+    if (i === 0)
+      return r;
+    i < 0 ? s = r : e = r + 1;
+  }
+  return -1;
+}
+/**
+ * @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 Rs() {
+  return g;
+}
+function E(n, t) {
+  return g.tidy(n, t);
+}
+function M(n) {
+  ae(n).forEach((e) => e.dispose());
+}
+function mn(n) {
+  return g.keep(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.
+ * =============================================================================
+ */
+const $t = typeof Buffer < "u" && (typeof Blob > "u" || typeof atob > "u" || typeof btoa > "u");
+function jt(n) {
+  return $t ? Buffer.byteLength(n, "utf8") : new Blob([n]).size;
+}
+function pn(n) {
+  if ($t)
+    return Buffer.from(n).toString("base64");
+  const t = new Uint8Array(n);
+  let e = "";
+  for (let s = 0, r = t.length; s < r; s++)
+    e += String.fromCharCode(t[s]);
+  return btoa(e);
+}
+function yn(n) {
+  if ($t) {
+    const s = Buffer.from(n, "base64");
+    return s.buffer.slice(s.byteOffset, s.byteOffset + s.byteLength);
+  }
+  const t = atob(n), e = new Uint8Array(t.length);
+  for (let s = 0; s < t.length; ++s)
+    e.set([t.charCodeAt(s)], s);
+  return e.buffer;
+}
+function he(n) {
+  if (n.modelTopology instanceof ArrayBuffer)
+    throw new Error("Expected JSON model topology, received ArrayBuffer.");
+  return {
+    dateSaved: /* @__PURE__ */ new Date(),
+    modelTopologyType: "JSON",
+    modelTopologyBytes: n.modelTopology == null ? 0 : jt(JSON.stringify(n.modelTopology)),
+    weightSpecsBytes: n.weightSpecs == null ? 0 : jt(JSON.stringify(n.weightSpecs)),
+    weightDataBytes: n.weightData == null ? 0 : new at(n.weightData).byteLength
+  };
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+class B {
+  constructor() {
+    this.saveRouters = [], this.loadRouters = [];
+  }
+  static getInstance() {
+    return B.instance == null && (B.instance = new B()), B.instance;
+  }
+  /**
+   * Register a save-handler router.
+   *
+   * @param saveRouter A function that maps a URL-like string onto an instance
+   * of `IOHandler` with the `save` method defined or `null`.
+   */
+  static registerSaveRouter(t) {
+    B.getInstance().saveRouters.push(t);
+  }
+  /**
+   * Register a load-handler router.
+   *
+   * @param loadRouter A function that maps a URL-like string onto an instance
+   * of `IOHandler` with the `load` method defined or `null`.
+   */
+  static registerLoadRouter(t) {
+    B.getInstance().loadRouters.push(t);
+  }
+  /**
+   * Look up IOHandler for saving, given a URL-like string.
+   *
+   * @param url
+   * @returns If only one match is found, an instance of IOHandler with the
+   * `save` method defined. If no match is found, `null`.
+   * @throws Error, if more than one match is found.
+   */
+  static getSaveHandlers(t) {
+    return B.getHandlers(t, "save");
+  }
+  /**
+   * Look up IOHandler for loading, given a URL-like string.
+   *
+   * @param url
+   * @param loadOptions Optional, custom load options.
+   * @returns All valid handlers for `url`, given the currently registered
+   *   handler routers.
+   */
+  static getLoadHandlers(t, e) {
+    return B.getHandlers(t, "load", e);
+  }
+  static getHandlers(t, e, s) {
+    const r = [];
+    return (e === "load" ? B.getInstance().loadRouters : B.getInstance().saveRouters).forEach((o) => {
+      const a = o(t, s);
+      a !== null && r.push(a);
+    }), 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 Tt = "tensorflowjs", Et = 1, L = "models_store", O = "model_info_store";
+function fe() {
+  if (!S().getBool("IS_BROWSER"))
+    throw new Error("Failed to obtain IndexedDB factory because the current environmentis not a web browser.");
+  const n = typeof window > "u" ? self : window, t = n.indexedDB || n.mozIndexedDB || n.webkitIndexedDB || n.msIndexedDB || n.shimIndexedDB;
+  if (t == null)
+    throw new Error("The current browser does not appear to support IndexedDB.");
+  return t;
+}
+function Bt(n) {
+  const t = n.result;
+  t.createObjectStore(L, { keyPath: "modelPath" }), t.createObjectStore(O, { keyPath: "modelPath" });
+}
+class z {
+  constructor(t) {
+    if (this.indexedDB = fe(), t == null || !t)
+      throw new Error("For IndexedDB, modelPath must not be null, undefined or empty.");
+    this.modelPath = t;
+  }
+  async save(t) {
+    if (t.modelTopology instanceof ArrayBuffer)
+      throw new Error("BrowserLocalStorage.save() does not support saving model topology in binary formats yet.");
+    return this.databaseAction(this.modelPath, t);
+  }
+  async load() {
+    return this.databaseAction(this.modelPath);
+  }
+  /**
+   * Perform database action to put model artifacts into or read model artifacts
+   * from IndexedDB object store.
+   *
+   * Whether the action is put or get depends on whether `modelArtifacts` is
+   * specified. If it is specified, the action will be put; otherwise the action
+   * will be get.
+   *
+   * @param modelPath A unique string path for the model.
+   * @param modelArtifacts If specified, it will be the model artifacts to be
+   *   stored in IndexedDB.
+   * @returns A `Promise` of `SaveResult`, if the action is put, or a `Promise`
+   *   of `ModelArtifacts`, if the action is get.
+   */
+  databaseAction(t, e) {
+    return new Promise((s, r) => {
+      const i = this.indexedDB.open(Tt, Et);
+      i.onupgradeneeded = () => Bt(i), i.onsuccess = () => {
+        const o = i.result;
+        if (e == null) {
+          const a = o.transaction(L, "readonly"), l = a.objectStore(L).get(this.modelPath);
+          l.onsuccess = () => {
+            if (l.result == null)
+              return o.close(), r(new Error(`Cannot find model with path '${this.modelPath}' in IndexedDB.`));
+            s(l.result.modelArtifacts);
+          }, l.onerror = (u) => (o.close(), r(l.error)), a.oncomplete = () => o.close();
+        } else {
+          e.weightData = at.join(e.weightData);
+          const a = he(e), c = o.transaction(O, "readwrite");
+          let l = c.objectStore(O), u;
+          try {
+            u = l.put({ modelPath: this.modelPath, modelArtifactsInfo: a });
+          } catch (f) {
+            return r(f);
+          }
+          let h;
+          u.onsuccess = () => {
+            h = o.transaction(L, "readwrite");
+            const f = h.objectStore(L);
+            let m;
+            try {
+              m = f.put({
+                modelPath: this.modelPath,
+                modelArtifacts: e,
+                modelArtifactsInfo: a
+              });
+            } catch (y) {
+              return r(y);
+            }
+            m.onsuccess = () => s({ modelArtifactsInfo: a }), m.onerror = (y) => {
+              l = c.objectStore(O);
+              const d = l.delete(this.modelPath);
+              d.onsuccess = () => (o.close(), r(m.error)), d.onerror = (I) => (o.close(), r(m.error));
+            };
+          }, u.onerror = (f) => (o.close(), r(u.error)), c.oncomplete = () => {
+            h == null ? o.close() : h.oncomplete = () => o.close();
+          };
+        }
+      }, i.onerror = (o) => r(i.error);
+    });
+  }
+}
+z.URL_SCHEME = "indexeddb://";
+const de = (n) => S().getBool("IS_BROWSER") && !Array.isArray(n) && n.startsWith(z.URL_SCHEME) ? bn(n.slice(z.URL_SCHEME.length)) : null;
+B.registerSaveRouter(de);
+B.registerLoadRouter(de);
+function bn(n) {
+  return new z(n);
+}
+function wn(n) {
+  return n.startsWith(z.URL_SCHEME) ? n.slice(z.URL_SCHEME.length) : n;
+}
+class Sn {
+  constructor() {
+    this.indexedDB = fe();
+  }
+  async listModels() {
+    return new Promise((t, e) => {
+      const s = this.indexedDB.open(Tt, Et);
+      s.onupgradeneeded = () => Bt(s), s.onsuccess = () => {
+        const r = s.result, i = r.transaction(O, "readonly"), a = i.objectStore(O).getAll();
+        a.onsuccess = () => {
+          const c = {};
+          for (const l of a.result)
+            c[l.modelPath] = l.modelArtifactsInfo;
+          t(c);
+        }, a.onerror = (c) => (r.close(), e(a.error)), i.oncomplete = () => r.close();
+      }, s.onerror = (r) => e(s.error);
+    });
+  }
+  async removeModel(t) {
+    return t = wn(t), new Promise((e, s) => {
+      const r = this.indexedDB.open(Tt, Et);
+      r.onupgradeneeded = () => Bt(r), r.onsuccess = () => {
+        const i = r.result, o = i.transaction(O, "readwrite"), a = o.objectStore(O), c = a.get(t);
+        let l;
+        c.onsuccess = () => {
+          if (c.result == null)
+            return i.close(), s(new Error(`Cannot find model with path '${t}' in IndexedDB.`));
+          {
+            const u = a.delete(t), h = () => {
+              l = i.transaction(L, "readwrite");
+              const m = l.objectStore(L).delete(t);
+              m.onsuccess = () => e(c.result.modelArtifactsInfo), m.onerror = (y) => s(c.error);
+            };
+            u.onsuccess = h, u.onerror = (f) => (h(), i.close(), s(c.error));
+          }
+        }, c.onerror = (u) => (i.close(), s(c.error)), o.oncomplete = () => {
+          l == null ? i.close() : l.oncomplete = () => i.close();
+        };
+      }, r.onerror = (i) => s(r.error);
+    });
+  }
+}
+/**
+ * @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 _ = "/", X = "tensorflowjs_models", ge = "info", In = "model_topology", kn = "weight_specs", Tn = "weight_data", En = "model_metadata";
+function me(n) {
+  return {
+    info: [X, n, ge].join(_),
+    topology: [X, n, In].join(_),
+    weightSpecs: [X, n, kn].join(_),
+    weightData: [X, n, Tn].join(_),
+    modelMetadata: [X, n, En].join(_)
+  };
+}
+function pe(n) {
+  for (const t of Object.values(n))
+    window.localStorage.removeItem(t);
+}
+function Bn(n) {
+  const t = n.split(_);
+  if (t.length < 3)
+    throw new Error(`Invalid key format: ${n}`);
+  return t.slice(1, t.length - 1).join(_);
+}
+function An(n) {
+  return n.startsWith(W.URL_SCHEME) ? n.slice(W.URL_SCHEME.length) : n;
+}
+class W {
+  constructor(t) {
+    if (!S().getBool("IS_BROWSER") || typeof window > "u" || typeof window.localStorage > "u")
+      throw new Error("The current environment does not support local storage.");
+    if (this.LS = window.localStorage, t == null || !t)
+      throw new Error("For local storage, modelPath must not be null, undefined or empty.");
+    this.modelPath = t, this.keys = me(this.modelPath);
+  }
+  /**
+   * Save model artifacts to browser local storage.
+   *
+   * See the documentation to `browserLocalStorage` for details on the saved
+   * artifacts.
+   *
+   * @param modelArtifacts The model artifacts to be stored.
+   * @returns An instance of SaveResult.
+   */
+  async save(t) {
+    if (t.modelTopology instanceof ArrayBuffer)
+      throw new Error("BrowserLocalStorage.save() does not support saving model topology in binary formats yet.");
+    {
+      const e = JSON.stringify(t.modelTopology), s = JSON.stringify(t.weightSpecs), r = he(t), i = at.join(t.weightData);
+      try {
+        this.LS.setItem(this.keys.info, JSON.stringify(r)), this.LS.setItem(this.keys.topology, e), this.LS.setItem(this.keys.weightSpecs, s), this.LS.setItem(this.keys.weightData, pn(i));
+        const o = {
+          format: t.format,
+          generatedBy: t.generatedBy,
+          convertedBy: t.convertedBy,
+          signature: t.signature != null ? t.signature : void 0,
+          userDefinedMetadata: t.userDefinedMetadata != null ? t.userDefinedMetadata : void 0,
+          modelInitializer: t.modelInitializer != null ? t.modelInitializer : void 0,
+          initializerSignature: t.initializerSignature != null ? t.initializerSignature : void 0,
+          trainingConfig: t.trainingConfig != null ? t.trainingConfig : void 0
+        };
+        return this.LS.setItem(this.keys.modelMetadata, JSON.stringify(o)), { modelArtifactsInfo: r };
+      } catch {
+        throw pe(this.keys), new Error(`Failed to save model '${this.modelPath}' to local storage: size quota being exceeded is a possible cause of this failure: modelTopologyBytes=${r.modelTopologyBytes}, weightSpecsBytes=${r.weightSpecsBytes}, weightDataBytes=${r.weightDataBytes}.`);
+      }
+    }
+  }
+  /**
+   * Load a model from local storage.
+   *
+   * See the documentation to `browserLocalStorage` for details on the saved
+   * artifacts.
+   *
+   * @returns The loaded model (if loading succeeds).
+   */
+  async load() {
+    const t = JSON.parse(this.LS.getItem(this.keys.info));
+    if (t == null)
+      throw new Error(`In local storage, there is no model with name '${this.modelPath}'`);
+    if (t.modelTopologyType !== "JSON")
+      throw new Error("BrowserLocalStorage does not support loading non-JSON model topology yet.");
+    const e = {}, s = JSON.parse(this.LS.getItem(this.keys.topology));
+    if (s == null)
+      throw new Error(`In local storage, the topology of model '${this.modelPath}' is missing.`);
+    e.modelTopology = s;
+    const r = JSON.parse(this.LS.getItem(this.keys.weightSpecs));
+    if (r == null)
+      throw new Error(`In local storage, the weight specs of model '${this.modelPath}' are missing.`);
+    e.weightSpecs = r;
+    const i = this.LS.getItem(this.keys.modelMetadata);
+    if (i != null) {
+      const a = JSON.parse(i);
+      e.format = a.format, e.generatedBy = a.generatedBy, e.convertedBy = a.convertedBy, a.signature != null && (e.signature = a.signature), a.userDefinedMetadata != null && (e.userDefinedMetadata = a.userDefinedMetadata), a.modelInitializer != null && (e.modelInitializer = a.modelInitializer), a.initializerSignature != null && (e.initializerSignature = a.initializerSignature), a.trainingConfig != null && (e.trainingConfig = a.trainingConfig);
+    }
+    const o = this.LS.getItem(this.keys.weightData);
+    if (o == null)
+      throw new Error(`In local storage, the binary weight values of model '${this.modelPath}' are missing.`);
+    return e.weightData = yn(o), e;
+  }
+}
+W.URL_SCHEME = "localstorage://";
+const ye = (n) => S().getBool("IS_BROWSER") && !Array.isArray(n) && n.startsWith(W.URL_SCHEME) ? vn(n.slice(W.URL_SCHEME.length)) : null;
+B.registerSaveRouter(ye);
+B.registerLoadRouter(ye);
+function vn(n) {
+  return new W(n);
+}
+class Mn {
+  constructor() {
+    b(S().getBool("IS_BROWSER"), () => "Current environment is not a web browser"), b(typeof window > "u" || typeof window.localStorage < "u", () => "Current browser does not appear to support localStorage"), this.LS = window.localStorage;
+  }
+  async listModels() {
+    const t = {}, e = X + _, s = _ + ge;
+    for (let r = 0; r < this.LS.length; ++r) {
+      const i = this.LS.key(r);
+      if (i.startsWith(e) && i.endsWith(s)) {
+        const o = Bn(i);
+        t[o] = JSON.parse(this.LS.getItem(i));
+      }
+    }
+    return t;
+  }
+  async removeModel(t) {
+    t = An(t);
+    const e = me(t);
+    if (this.LS.getItem(e.info) == null)
+      throw new Error(`Cannot find model at path '${t}'`);
+    const s = JSON.parse(this.LS.getItem(e.info));
+    return pe(e), s;
+  }
+}
+/**
+ * @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 Kt = "://";
+class $ {
+  constructor() {
+    this.managers = {};
+  }
+  static getInstance() {
+    return $.instance == null && ($.instance = new $()), $.instance;
+  }
+  /**
+   * Register a save-handler router.
+   *
+   * @param saveRouter A function that maps a URL-like string onto an instance
+   * of `IOHandler` with the `save` method defined or `null`.
+   */
+  static registerManager(t, e) {
+    b(t != null, () => "scheme must not be undefined or null."), t.endsWith(Kt) && (t = t.slice(0, t.indexOf(Kt))), b(t.length > 0, () => "scheme must not be an empty string.");
+    const s = $.getInstance();
+    b(s.managers[t] == null, () => `A model store manager is already registered for scheme '${t}'.`), s.managers[t] = e;
+  }
+  static getManager(t) {
+    const e = $.getInstance().managers[t];
+    if (e == null)
+      throw new Error(`Cannot find model manager for scheme '${t}'`);
+    return e;
+  }
+  static getSchemes() {
+    return Object.keys($.getInstance().managers);
+  }
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+class Fn {
+  constructor() {
+    this.messageName = "setTimeoutCustom", this.functionRefs = [], this.handledMessageCount = 0, this.hasEventListener = !1;
+  }
+  fetch(t, e) {
+    return fetch(t, e);
+  }
+  now() {
+    return performance.now();
+  }
+  encode(t, e) {
+    if (e !== "utf-8" && e !== "utf8")
+      throw new Error(`Browser's encoder only supports utf-8, but got ${e}`);
+    return this.textEncoder == null && (this.textEncoder = new TextEncoder()), this.textEncoder.encode(t);
+  }
+  decode(t, e) {
+    return new TextDecoder(e).decode(t);
+  }
+  // If the setTimeout nesting level is greater than 5 and timeout is less
+  // than 4ms, timeout will be clamped to 4ms, which hurts the perf.
+  // Interleaving window.postMessage and setTimeout will trick the browser and
+  // avoid the clamp.
+  setTimeoutCustom(t, e) {
+    if (typeof window > "u" || !S().getBool("USE_SETTIMEOUTCUSTOM")) {
+      setTimeout(t, e);
+      return;
+    }
+    this.functionRefs.push(t), setTimeout(() => {
+      window.postMessage({ name: this.messageName, index: this.functionRefs.length - 1 }, "*");
+    }, e), this.hasEventListener || (this.hasEventListener = !0, window.addEventListener("message", (s) => {
+      if (s.source === window && s.data.name === this.messageName) {
+        s.stopPropagation();
+        const r = this.functionRefs[s.data.index];
+        r(), this.handledMessageCount++, this.handledMessageCount === this.functionRefs.length && (this.functionRefs = [], this.handledMessageCount = 0);
+      }
+    }, !0));
+  }
+  isTypedArray(t) {
+    return ee(t);
+  }
+}
+if (S().get("IS_BROWSER")) {
+  S().setPlatform("browser", new Fn());
+  try {
+    $.registerManager(W.URL_SCHEME, new Mn());
+  } catch {
+  }
+  try {
+    $.registerManager(z.URL_SCHEME, new Sn());
+  } catch {
+  }
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+const Rn = {
+  // tslint:disable-next-line:no-require-imports
+  importFetch: () => require("node-fetch")
+};
+let pt;
+class xn {
+  constructor() {
+    this.util = require("util"), this.textEncoder = new this.util.TextEncoder();
+  }
+  fetch(t, e) {
+    return S().global.fetch != null ? S().global.fetch(t, e) : (pt == null && (pt = Rn.importFetch()), pt(t, e));
+  }
+  now() {
+    const t = process.hrtime();
+    return t[0] * 1e3 + t[1] / 1e6;
+  }
+  encode(t, e) {
+    if (e !== "utf-8" && e !== "utf8")
+      throw new Error(`Node built-in encoder only supports utf-8, but got ${e}`);
+    return this.textEncoder.encode(t);
+  }
+  decode(t, e) {
+    return t.length === 0 ? "" : new this.util.TextDecoder(e).decode(t);
+  }
+  isTypedArray(t) {
+    return this.util.types.isFloat32Array(t) || this.util.types.isInt32Array(t) || this.util.types.isUint8Array(t) || this.util.types.isUint8ClampedArray(t);
+  }
+}
+S().get("IS_NODE") && !S().get("IS_BROWSER") && S().setPlatform("node", new xn());
+/**
+ * @license
+ * Copyright 2020 Google Inc. 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 Nn(n, t = "float32", e) {
+  return t = t || "float32", Rt(n), new en(n, t, e);
+}
+/**
+ * @license
+ * Copyright 2020 Google Inc. 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(n, t) {
+  const e = k(n, "x", "cast");
+  if (!ke(t))
+    throw new Error(`Failed to cast to unknown dtype ${t}`);
+  if (t === "string" && e.dtype !== "string" || t !== "string" && e.dtype === "string")
+    throw new Error("Only strings can be casted to strings");
+  const s = { x: e }, r = { dtype: t };
+  return g.runKernel(Qt, s, r);
+}
+const At = /* @__PURE__ */ F({ cast_: $n });
+/**
+ * @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 Dn(n) {
+  const e = { x: k(n, "x", "clone", "string_or_numeric") };
+  return g.runKernel(Zt, e);
+}
+const Cn = /* @__PURE__ */ F({ clone_: Dn });
+/**
+ * @license
+ * Copyright 2020 Google Inc. 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(n, t = !1) {
+  console.log(n.toString(t));
+}
+/**
+ * @license
+ * Copyright 2020 Google Inc. 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.
+ * =============================================================================
+ */
+ce();
+const On = {
+  buffer: Nn,
+  cast: At,
+  clone: Cn,
+  print: _n
+};
+sn(On);
+/**
+ * @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 Pn(n, t) {
+  let e = k(n, "a", "add"), s = k(t, "b", "add");
+  [e, s] = K(e, s);
+  const r = { a: e, b: s };
+  return g.runKernel(Yt, r);
+}
+const w = /* @__PURE__ */ F({ add_: Pn });
+/**
+ * @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 Ln(n, t) {
+  let e = k(n, "a", "floorDiv"), s = k(t, "b", "floorDiv");
+  [e, s] = K(e, s);
+  const r = { a: e, b: s };
+  return g.runKernel(Oe, r);
+}
+const Un = /* @__PURE__ */ F({ floorDiv_: Ln });
+/**
+ * @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 Gn(n, t) {
+  let e = k(n, "a", "div"), s = k(t, "b", "div");
+  if ([e, s] = K(e, s), e.dtype === "int32" && s.dtype === "int32")
+    return Un(e, s);
+  const r = { a: e, b: s }, i = {};
+  return g.runKernel(Ce, r, i);
+}
+const D = /* @__PURE__ */ F({ div_: Gn });
+/**
+ * @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 zn(n, t) {
+  let e = k(n, "a", "mul"), s = k(t, "b", "mul");
+  [e, s] = K(e, s);
+  const r = { a: e, b: s };
+  return g.runKernel(Le, r);
+}
+const p = /* @__PURE__ */ F({ mul_: zn });
+/**
+ * @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 Wn(n) {
+  const t = k(n, "x", "abs");
+  if (t.dtype === "complex64") {
+    const e = { x: t };
+    return g.runKernel(De, e);
+  } else {
+    const e = { x: t };
+    return g.runKernel($e, e);
+  }
+}
+const jn = /* @__PURE__ */ F({ abs_: Wn });
+/**
+ * @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 Kn(n, t, e) {
+  Rt(n), e = e || ft(t);
+  const s = { shape: n, value: t, dtype: e };
+  return g.runKernel(_e, {}, 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.
+ * =============================================================================
+ */
+function xs(n, t) {
+  const e = [];
+  for (let s = 0; s < t.length; s++) {
+    const r = n[n.length - s - 1], i = t.length - s - 1, o = t[i];
+    (r == null || r === 1 && o > 1) && e.unshift(i);
+  }
+  return e;
+}
+function Vn(n, t) {
+  const e = Math.max(n.length, t.length), s = new Array(e);
+  for (let r = 0; r < e; r++) {
+    let i = n[n.length - r - 1];
+    i == null && (i = 1);
+    let o = t[t.length - r - 1];
+    if (o == null && (o = 1), i === 1)
+      s[e - r - 1] = o;
+    else if (o === 1)
+      s[e - r - 1] = i;
+    else if (i !== o) {
+      const a = `Operands could not be broadcast together with shapes ${n} and ${t}.`;
+      throw Error(a);
+    } else
+      s[e - r - 1] = i;
+  }
+  return s;
+}
+/**
+ * @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 qn(n) {
+  const e = { x: k(n, "x", "zerosLike") };
+  return g.runKernel(We, e);
+}
+const C = /* @__PURE__ */ F({ zerosLike_: qn });
+/**
+ * @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 Hn(n, t) {
+  let e = k(n, "base", "pow"), s = k(t, "exp", "pow");
+  [e, s] = K(e, s);
+  const r = { a: e, b: s };
+  return g.runKernel(Ue, r);
+}
+const Vt = /* @__PURE__ */ F({ pow_: Hn });
+/**
+ * @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 j(n, t) {
+  if ((R(n) && t !== "string" || Array.isArray(n)) && t !== "complex64")
+    throw new Error("Error creating a new Scalar: value must be a primitive (number|boolean|string)");
+  if (t === "string" && R(n) && !(n instanceof Uint8Array))
+    throw new Error("When making a scalar from encoded string, the value must be `Uint8Array`.");
+  return dn(n, [], [], t);
+}
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function Jn(n) {
+  const e = { x: k(n, "x", "sqrt", "float32") };
+  return g.runKernel(Ge, e);
+}
+const Z = /* @__PURE__ */ F({ sqrt_: Jn });
+/**
+ * @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 Xn(n) {
+  const t = k(n, "x", "square"), e = {};
+  return g.runKernel("Square", { x: t }, e);
+}
+const G = /* @__PURE__ */ F({ square_: Xn });
+/**
+ * @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 Yn(n, t) {
+  b(bt(n), () => "The f passed in variableGrads(f) must be a function"), b(t == null || Array.isArray(t) && t.every((l) => l instanceof ht), () => "The varList passed in variableGrads(f, varList) must be an array of variables");
+  const e = t != null;
+  if (!e) {
+    t = [];
+    for (const l in g.registeredVariables)
+      t.push(g.registeredVariables[l]);
+  }
+  const s = e ? t.filter((l) => !l.trainable) : null, r = t.length;
+  t = t.filter((l) => l.trainable), b(t.length > 0, () => `variableGrads() expects at least one of the input variables to be trainable, but none of the ${r} variables is trainable.`);
+  const i = !0, { value: o, grads: a } = g.gradients(n, t, null, i);
+  b(a.some((l) => l != null), () => "Cannot find a connection between any variable and the result of the loss function y=f(x). Please make sure the operations that use variables are inside the function f passed to minimize()."), b(o.rank === 0, () => `The f passed in variableGrads(f) must return a scalar, but it returned a rank-${o.rank} tensor`);
+  const c = {};
+  return t.forEach((l, u) => {
+    a[u] != null && (c[l.name] = a[u]);
+  }), s?.forEach((l) => c[l.name] = null), { value: o, grads: c };
+}
+function Ns(n) {
+  return g.customGrad(n);
+}
+/**
+ * @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 Qn(n, t) {
+  let e = k(n, "a", "sub"), s = k(t, "b", "sub");
+  [e, s] = K(e, s);
+  const r = { a: e, b: s };
+  return g.runKernel(ze, r);
+}
+const Y = /* @__PURE__ */ F({ sub_: Qn });
+/**
+ * @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 Zn(n, t) {
+  let e = k(n, "a", "maximum"), s = k(t, "b", "maximum");
+  [e, s] = K(e, s), e.dtype === "bool" && (e = At(e, "int32"), s = At(s, "int32")), Vn(e.shape, s.shape);
+  const r = { a: e, b: s };
+  return g.runKernel(Pe, r);
+}
+const ts = /* @__PURE__ */ F({ maximum_: Zn });
+/**
+ * @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 es = /* @__PURE__ */ new Map(), ns = /* @__PURE__ */ new Map();
+class ss {
+  /**
+   * Return the class name for this class to use in serialization contexts.
+   *
+   * Generally speaking this will be the same thing that constructor.name
+   * would have returned.  However, the class name needs to be robust
+   * against minification for serialization/deserialization to work properly.
+   *
+   * There's also places such as initializers.VarianceScaling, where
+   * implementation details between different languages led to different
+   * class hierarchies and a non-leaf node is used for serialization purposes.
+   */
+  getClassName() {
+    return this.constructor.className;
+  }
+  /**
+   * Creates an instance of T from a ConfigDict.
+   *
+   * This works for most descendants of serializable.  A few need to
+   * provide special handling.
+   * @param cls A Constructor for the class to instantiate.
+   * @param config The Configuration for the object.
+   */
+  /** @nocollapse */
+  static fromConfig(t, e) {
+    return new t(e);
+  }
+}
+class P {
+  constructor() {
+    this.classNameMap = {};
+  }
+  /**
+   * Returns the singleton instance of the map.
+   */
+  static getMap() {
+    return P.instance == null && (P.instance = new P()), P.instance;
+  }
+  /**
+   * Registers the class as serializable.
+   */
+  static register(t) {
+    P.getMap().classNameMap[t.className] = [t, t.fromConfig];
+  }
+}
+function rs(n, t, e) {
+  b(n.className != null, () => "Class being registered does not have the static className property defined."), b(typeof n.className == "string", () => "className is required to be a string, but got type " + typeof n.className), b(n.className.length > 0, () => "Class being registered has an empty-string as its className, which is disallowed."), typeof t > "u" && (t = "Custom"), typeof e > "u" && (e = n.className);
+  const s = e, r = t + ">" + s;
+  return P.register(n), es.set(r, n), ns.set(n, r), 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.
+ * =============================================================================
+ */
+class V extends ss {
+  /**
+   * Executes `f()` and minimizes the scalar output of `f()` by computing
+   * gradients of y with respect to the list of trainable variables provided by
+   * `varList`. If no list is provided, it defaults to all trainable variables.
+   *
+   * @param f The function to execute and whose output to minimize.
+   * @param returnCost Whether to return the scalar cost value produced by
+   * executing `f()`.
+   * @param varList An optional list of variables to update. If specified, only
+   * the trainable variables in varList will be updated by minimize. Defaults to
+   * all trainable variables.
+   *
+   * @doc {heading: 'Training', subheading: 'Optimizers'}
+   */
+  minimize(t, e = !1, s) {
+    const { value: r, grads: i } = this.computeGradients(t, s);
+    if (s != null) {
+      const o = s.map((a) => ({ name: a.name, tensor: i[a.name] }));
+      this.applyGradients(o);
+    } else
+      this.applyGradients(i);
+    return M(i), e ? r : (r.dispose(), null);
+  }
+  /**
+   * The number of iterations that this optimizer instance has been invoked for.
+   */
+  get iterations() {
+    return this.iterations_ == null && (this.iterations_ = 0), this.iterations_;
+  }
+  incrementIterations() {
+    this.iterations_ = this.iterations + 1;
+  }
+  /**
+   * Executes f() and computes the gradient of the scalar output of f() with
+   * respect to the list of trainable variables provided by `varList`. If no
+   * list is provided, it defaults to all trainable variables.
+   *
+   * @param f The function to execute and whose output to use for computing
+   * gradients with respect to variables.
+   * @param varList An optional list of variables to compute gradients with
+   * respect to. If specified, only the trainable variables in varList will have
+   * gradients computed with respect to. Defaults to all trainable variables.
+   *
+   * @doc {heading: 'Training', subheading: 'Optimizers'}
+   */
+  computeGradients(t, e) {
+    return Yn(t, e);
+  }
+  /**
+   * Dispose the variables (if any) owned by this optimizer instance.
+   */
+  dispose() {
+    this.iterations_ != null && M(this.iterations_);
+  }
+  async saveIterations() {
+    return this.iterations_ == null && (this.iterations_ = 0), {
+      name: "iter",
+      // TODO(cais): Use 'int64' type when available.
+      tensor: j(this.iterations_, "int32")
+    };
+  }
+  async getWeights() {
+    throw new Error("getWeights() is not implemented for this optimizer yet.");
+  }
+  async setWeights(t) {
+    throw new Error(`setWeights() is not implemented for this optimizer class ${this.getClassName()}`);
+  }
+  /**
+   * Extract the first element of the weight values and set it
+   * as the iterations counter variable of this instance of optimizer.
+   *
+   * @param weightValues
+   * @returns Weight values with the first element consumed and excluded.
+   */
+  async extractIterations(t) {
+    return this.iterations_ = (await t[0].tensor.data())[0], t.slice(1);
+  }
+}
+Object.defineProperty(V, Symbol.hasInstance, {
+  value: (n) => n.minimize != null && n.computeGradients != null && n.applyGradients != null
+});
+/**
+ * @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.
+ * =============================================================================
+ */
+class is extends V {
+  /** @nocollapse */
+  static get className() {
+    return "Adadelta";
+  }
+  constructor(t, e, s = null) {
+    super(), this.learningRate = t, this.rho = e, this.epsilon = s, this.accumulatedGrads = [], this.accumulatedUpdates = [], s == null && (this.epsilon = g.backend.epsilon());
+  }
+  applyGradients(t) {
+    (Array.isArray(t) ? t.map((s) => s.name) : Object.keys(t)).forEach((s, r) => {
+      const i = g.registeredVariables[s], o = !1;
+      this.accumulatedGrads[r] == null && (this.accumulatedGrads[r] = {
+        originalName: `${s}/accum_grad`,
+        variable: E(() => C(i).variable(o))
+      }), this.accumulatedUpdates[r] == null && (this.accumulatedUpdates[r] = {
+        originalName: `${s}/accum_var`,
+        variable: E(() => C(i).variable(o))
+      });
+      const a = Array.isArray(t) ? t[r].tensor : t[s];
+      if (a == null)
+        return;
+      const c = this.accumulatedGrads[r].variable, l = this.accumulatedUpdates[r].variable;
+      E(() => {
+        const u = w(p(c, this.rho), p(G(a), 1 - this.rho)), h = p(D(Z(w(l, this.epsilon)), Z(w(c, this.epsilon))), a), f = w(p(l, this.rho), p(G(h), 1 - this.rho));
+        c.assign(u), l.assign(f);
+        const m = w(p(h, -this.learningRate), i);
+        i.assign(m);
+      });
+    }), this.incrementIterations();
+  }
+  dispose() {
+    this.accumulatedUpdates != null && (M(this.accumulatedGrads.map((t) => t.variable)), M(this.accumulatedUpdates.map((t) => t.variable)));
+  }
+  async getWeights() {
+    const t = [...this.accumulatedGrads, ...this.accumulatedUpdates];
+    return [await this.saveIterations()].concat(t.map((e) => ({ name: e.originalName, tensor: e.variable })));
+  }
+  async setWeights(t) {
+    t = await this.extractIterations(t);
+    const e = t.length / 2, s = !1;
+    this.accumulatedGrads = t.slice(0, e).map((r) => ({
+      originalName: r.name,
+      variable: r.tensor.variable(s)
+    })), this.accumulatedUpdates = t.slice(e, e * 2).map((r) => ({
+      originalName: r.name,
+      variable: r.tensor.variable(s)
+    }));
+  }
+  getConfig() {
+    return {
+      learningRate: this.learningRate,
+      rho: this.rho,
+      epsilon: this.epsilon
+    };
+  }
+  /** @nocollapse */
+  static fromConfig(t, e) {
+    return new t(e.learningRate, e.rho, e.epsilon);
+  }
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+class os extends V {
+  /** @nocollapse */
+  static get className() {
+    return "Adagrad";
+  }
+  constructor(t, e = 0.1) {
+    super(), this.learningRate = t, this.initialAccumulatorValue = e, this.accumulatedGrads = [];
+  }
+  applyGradients(t) {
+    (Array.isArray(t) ? t.map((s) => s.name) : Object.keys(t)).forEach((s, r) => {
+      const i = g.registeredVariables[s];
+      this.accumulatedGrads[r] == null && (this.accumulatedGrads[r] = {
+        originalName: `${s}/accumulator`,
+        variable: E(() => Kn(i.shape, this.initialAccumulatorValue).variable(!1))
+      });
+      const o = Array.isArray(t) ? t[r].tensor : t[s];
+      if (o == null)
+        return;
+      const a = this.accumulatedGrads[r].variable;
+      E(() => {
+        const c = w(a, G(o));
+        a.assign(c);
+        const l = w(p(D(o, Z(w(c, g.backend.epsilon()))), -this.learningRate), i);
+        i.assign(l);
+      });
+    }), this.incrementIterations();
+  }
+  dispose() {
+    this.accumulatedGrads != null && M(this.accumulatedGrads.map((t) => t.variable));
+  }
+  async getWeights() {
+    return [await this.saveIterations()].concat(this.accumulatedGrads.map((t) => ({ name: t.originalName, tensor: t.variable })));
+  }
+  async setWeights(t) {
+    t = await this.extractIterations(t);
+    const e = !1;
+    this.accumulatedGrads = t.map((s) => ({ originalName: s.name, variable: s.tensor.variable(e) }));
+  }
+  getConfig() {
+    return {
+      learningRate: this.learningRate,
+      initialAccumulatorValue: this.initialAccumulatorValue
+    };
+  }
+  /** @nocollapse */
+  static fromConfig(t, e) {
+    return new t(e.learningRate, e.initialAccumulatorValue);
+  }
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+class as extends V {
+  /** @nocollapse */
+  static get className() {
+    return "Adam";
+  }
+  constructor(t, e, s, r = null) {
+    super(), this.learningRate = t, this.beta1 = e, this.beta2 = s, this.epsilon = r, this.accumulatedFirstMoment = [], this.accumulatedSecondMoment = [], E(() => {
+      this.accBeta1 = j(e).variable(), this.accBeta2 = j(s).variable();
+    }), r == null && (this.epsilon = g.backend.epsilon());
+  }
+  applyGradients(t) {
+    const e = Array.isArray(t) ? t.map((s) => s.name) : Object.keys(t);
+    E(() => {
+      const s = Y(1, this.accBeta1), r = Y(1, this.accBeta2);
+      e.forEach((i, o) => {
+        const a = g.registeredVariables[i], c = !1;
+        this.accumulatedFirstMoment[o] == null && (this.accumulatedFirstMoment[o] = {
+          originalName: `${i}/m`,
+          variable: E(() => C(a).variable(c))
+        }), this.accumulatedSecondMoment[o] == null && (this.accumulatedSecondMoment[o] = {
+          originalName: `${i}/v`,
+          variable: E(() => C(a).variable(c))
+        });
+        const l = Array.isArray(t) ? t[o].tensor : t[i];
+        if (l == null)
+          return;
+        const u = this.accumulatedFirstMoment[o].variable, h = this.accumulatedSecondMoment[o].variable, f = w(p(u, this.beta1), p(l, 1 - this.beta1)), m = w(p(h, this.beta2), p(G(l), 1 - this.beta2)), y = D(f, s), d = D(m, r);
+        u.assign(f), h.assign(m);
+        const I = w(p(D(y, w(Z(d), this.epsilon)), -this.learningRate), a);
+        a.assign(I);
+      }), this.accBeta1.assign(p(this.accBeta1, this.beta1)), this.accBeta2.assign(p(this.accBeta2, this.beta2));
+    }), this.incrementIterations();
+  }
+  dispose() {
+    this.accBeta1.dispose(), this.accBeta2.dispose(), this.accumulatedFirstMoment != null && M(this.accumulatedFirstMoment.map((t) => t.variable)), this.accumulatedSecondMoment != null && M(this.accumulatedSecondMoment.map((t) => t.variable));
+  }
+  async getWeights() {
+    const t = [...this.accumulatedFirstMoment, ...this.accumulatedSecondMoment];
+    return [await this.saveIterations()].concat(t.map((e) => ({ name: e.originalName, tensor: e.variable })));
+  }
+  async setWeights(t) {
+    t = await this.extractIterations(t), E(() => {
+      this.accBeta1.assign(Vt(this.beta1, this.iterations_ + 1)), this.accBeta2.assign(Vt(this.beta2, this.iterations_ + 1));
+    });
+    const e = t.length / 2, s = !1;
+    this.accumulatedFirstMoment = t.slice(0, e).map((r) => ({
+      originalName: r.name,
+      variable: r.tensor.variable(s)
+    })), this.accumulatedSecondMoment = t.slice(e, e * 2).map((r) => ({
+      originalName: r.name,
+      variable: r.tensor.variable(s)
+    }));
+  }
+  getConfig() {
+    return {
+      learningRate: this.learningRate,
+      beta1: this.beta1,
+      beta2: this.beta2,
+      epsilon: this.epsilon
+    };
+  }
+  /** @nocollapse */
+  static fromConfig(t, e) {
+    return new t(e.learningRate, e.beta1, e.beta2, e.epsilon);
+  }
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+class ls extends V {
+  /** @nocollapse */
+  static get className() {
+    return "Adamax";
+  }
+  constructor(t, e, s, r = null, i = 0) {
+    super(), this.learningRate = t, this.beta1 = e, this.beta2 = s, this.epsilon = r, this.decay = i, this.accumulatedFirstMoment = [], this.accumulatedWeightedInfNorm = [], E(() => {
+      this.iteration = j(0).variable(), this.accBeta1 = j(e).variable();
+    }), r == null && (this.epsilon = g.backend.epsilon());
+  }
+  applyGradients(t) {
+    const e = Array.isArray(t) ? t.map((s) => s.name) : Object.keys(t);
+    E(() => {
+      const s = Y(1, this.accBeta1), r = D(-this.learningRate, w(p(this.iteration, this.decay), 1));
+      e.forEach((i, o) => {
+        const a = g.registeredVariables[i], c = !1;
+        this.accumulatedFirstMoment[o] == null && (this.accumulatedFirstMoment[o] = {
+          originalName: `${i}/m`,
+          variable: C(a).variable(c)
+        }), this.accumulatedWeightedInfNorm[o] == null && (this.accumulatedWeightedInfNorm[o] = {
+          originalName: `${i}/v`,
+          variable: C(a).variable(c)
+        });
+        const l = Array.isArray(t) ? t[o].tensor : t[i];
+        if (l == null)
+          return;
+        const u = this.accumulatedFirstMoment[o].variable, h = this.accumulatedWeightedInfNorm[o].variable, f = w(p(u, this.beta1), p(l, 1 - this.beta1)), m = p(h, this.beta2), y = jn(l), d = ts(m, y);
+        u.assign(f), h.assign(d);
+        const I = w(p(D(r, s), D(f, w(d, this.epsilon))), a);
+        a.assign(I);
+      }), this.iteration.assign(w(this.iteration, 1)), this.accBeta1.assign(p(this.accBeta1, this.beta1));
+    }), this.incrementIterations();
+  }
+  dispose() {
+    this.accBeta1.dispose(), this.iteration.dispose(), this.accumulatedFirstMoment != null && M(this.accumulatedFirstMoment.map((t) => t.variable)), this.accumulatedWeightedInfNorm != null && M(this.accumulatedWeightedInfNorm.map((t) => t.variable));
+  }
+  async getWeights() {
+    throw new Error("getWeights() is not implemented for Adamax yet.");
+  }
+  async setWeights(t) {
+    throw new Error("setWeights() is not implemented for Adamax yet.");
+  }
+  getConfig() {
+    return {
+      learningRate: this.learningRate,
+      beta1: this.beta1,
+      beta2: this.beta2,
+      epsilon: this.epsilon,
+      decay: this.decay
+    };
+  }
+  /** @nocollapse */
+  static fromConfig(t, e) {
+    return new t(e.learningRate, e.beta1, e.beta2, e.epsilon, e.decay);
+  }
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+class be extends V {
+  /** @nocollapse */
+  static get className() {
+    return "SGD";
+  }
+  constructor(t) {
+    super(), this.learningRate = t, this.setLearningRate(t);
+  }
+  applyGradients(t) {
+    (Array.isArray(t) ? t.map((s) => s.name) : Object.keys(t)).forEach((s, r) => {
+      const i = Array.isArray(t) ? t[r].tensor : t[s];
+      if (i == null)
+        return;
+      const o = g.registeredVariables[s];
+      E(() => {
+        const a = w(p(this.c, i), o);
+        o.assign(a);
+      });
+    }), this.incrementIterations();
+  }
+  /**
+   * Sets the learning rate of the optimizer.
+   */
+  setLearningRate(t) {
+    this.learningRate = t, this.c != null && this.c.dispose(), this.c = mn(j(-t));
+  }
+  dispose() {
+    this.c.dispose();
+  }
+  async getWeights() {
+    return [await this.saveIterations()];
+  }
+  async setWeights(t) {
+    if (t = await this.extractIterations(t), t.length !== 0)
+      throw new Error("SGD optimizer does not have settable weights.");
+  }
+  getConfig() {
+    return { learningRate: this.learningRate };
+  }
+  /** @nocollapse */
+  static fromConfig(t, e) {
+    return new t(e.learningRate);
+  }
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+class cs extends be {
+  /** @nocollapse */
+  // Name matters for Python compatibility.
+  static get className() {
+    return "Momentum";
+  }
+  constructor(t, e, s = !1) {
+    super(t), this.learningRate = t, this.momentum = e, this.useNesterov = s, this.accumulations = [], this.m = j(this.momentum);
+  }
+  applyGradients(t) {
+    (Array.isArray(t) ? t.map((s) => s.name) : Object.keys(t)).forEach((s, r) => {
+      const i = g.registeredVariables[s];
+      this.accumulations[r] == null && (this.accumulations[r] = {
+        originalName: `${s}/momentum`,
+        variable: E(() => C(i).variable(!1))
+      });
+      const o = this.accumulations[r].variable, a = Array.isArray(t) ? t[r].tensor : t[s];
+      a != null && E(() => {
+        let c;
+        const l = w(p(this.m, o), a);
+        this.useNesterov ? c = w(p(this.c, w(a, p(l, this.m))), i) : c = w(p(this.c, l), i), o.assign(l), i.assign(c);
+      });
+    }), this.incrementIterations();
+  }
+  dispose() {
+    this.m.dispose(), this.accumulations != null && M(this.accumulations.map((t) => t.variable));
+  }
+  /**
+   * Sets the momentum of the optimizer.
+   *
+   * @param momentum
+   */
+  setMomentum(t) {
+    this.momentum = t;
+  }
+  async getWeights() {
+    return [await this.saveIterations()].concat(this.accumulations.map((t) => ({ name: t.originalName, tensor: t.variable })));
+  }
+  async setWeights(t) {
+    t = await this.extractIterations(t);
+    const e = !1;
+    this.accumulations = t.map((s) => ({ originalName: s.name, variable: s.tensor.variable(e) }));
+  }
+  getConfig() {
+    return {
+      learningRate: this.learningRate,
+      momentum: this.momentum,
+      useNesterov: this.useNesterov
+    };
+  }
+  /** @nocollapse */
+  static fromConfig(t, e) {
+    return new t(e.learningRate, e.momentum, e.useNesterov);
+  }
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+class us extends V {
+  /** @nocollapse */
+  static get className() {
+    return "RMSProp";
+  }
+  constructor(t, e = 0.9, s = 0, r = null, i = !1) {
+    if (super(), this.learningRate = t, this.decay = e, this.momentum = s, this.epsilon = r, this.accumulatedMeanSquares = [], this.accumulatedMoments = [], this.accumulatedMeanGrads = [], this.centered = i, r == null && (this.epsilon = g.backend.epsilon()), t == null)
+      throw new Error("learningRate for RMSPropOptimizer must be defined.");
+  }
+  applyGradients(t) {
+    (Array.isArray(t) ? t.map((s) => s.name) : Object.keys(t)).forEach((s, r) => {
+      const i = g.registeredVariables[s], o = !1;
+      this.accumulatedMeanSquares[r] == null && (this.accumulatedMeanSquares[r] = {
+        originalName: `${s}/rms`,
+        variable: E(() => C(i).variable(o))
+      }), this.accumulatedMoments[r] == null && (this.accumulatedMoments[r] = {
+        originalName: `${s}/momentum`,
+        variable: E(() => C(i).variable(o))
+      }), this.accumulatedMeanGrads[r] == null && this.centered && (this.accumulatedMeanGrads[r] = {
+        originalName: `${s}/mg`,
+        variable: E(() => C(i).variable(o))
+      });
+      const a = Array.isArray(t) ? t[r].tensor : t[s];
+      if (a == null)
+        return;
+      const c = this.accumulatedMeanSquares[r].variable, l = this.accumulatedMoments[r].variable;
+      E(() => {
+        const u = w(p(c, this.decay), p(G(a), 1 - this.decay));
+        if (this.centered) {
+          const h = this.accumulatedMeanGrads[r].variable, f = w(p(h, this.decay), p(a, 1 - this.decay)), m = D(p(a, this.learningRate), Z(Y(u, w(G(f), this.epsilon)))), y = w(p(l, this.momentum), m);
+          c.assign(u), h.assign(f), l.assign(y);
+          const d = Y(i, y);
+          i.assign(d);
+        } else {
+          const h = w(p(c, this.decay), p(G(a), 1 - this.decay)), f = w(p(l, this.momentum), D(p(a, this.learningRate), Z(w(h, this.epsilon))));
+          c.assign(h), l.assign(f);
+          const m = Y(i, f);
+          i.assign(m);
+        }
+      });
+    }), this.incrementIterations();
+  }
+  dispose() {
+    this.accumulatedMeanSquares != null && M(this.accumulatedMeanSquares.map((t) => t.variable)), this.accumulatedMeanGrads != null && this.centered && M(this.accumulatedMeanGrads.map((t) => t.variable)), this.accumulatedMoments != null && M(this.accumulatedMoments.map((t) => t.variable));
+  }
+  async getWeights() {
+    const t = [...this.accumulatedMeanSquares, ...this.accumulatedMoments];
+    return this.centered && t.push(...this.accumulatedMeanGrads), [await this.saveIterations()].concat(t.map((e) => ({ name: e.originalName, tensor: e.variable })));
+  }
+  async setWeights(t) {
+    t = await this.extractIterations(t);
+    const e = this.centered ? t.length / 3 : t.length / 2, s = !1;
+    this.accumulatedMeanSquares = t.slice(0, e).map((r) => ({
+      originalName: r.name,
+      variable: r.tensor.variable(s)
+    })), this.accumulatedMoments = t.slice(e, e * 2).map((r) => ({
+      originalName: r.name,
+      variable: r.tensor.variable(s)
+    })), this.centered && (this.accumulatedMeanGrads = t.slice(e * 2, e * 3).map((r) => ({
+      originalName: r.name,
+      variable: r.tensor.variable(s)
+    })));
+  }
+  getConfig() {
+    return {
+      learningRate: this.learningRate,
+      decay: this.decay,
+      momentum: this.momentum,
+      epsilon: this.epsilon,
+      centered: this.centered
+    };
+  }
+  /** @nocollapse */
+  static fromConfig(t, e) {
+    return new t(e.learningRate, e.decay, e.momentum, e.epsilon, e.centered);
+  }
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC.
+ * 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 hs = [
+  is,
+  os,
+  as,
+  ls,
+  cs,
+  us,
+  be
+];
+function fs() {
+  for (const n of hs)
+    rs(n);
+}
+/**
+ * @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.
+ * =============================================================================
+ */
+fs();
+export {
+  as as A,
+  gs as B,
+  ms as C,
+  g as E,
+  ys as I,
+  bs as L,
+  ws as N,
+  Ss as P,
+  Ts as R,
+  Bs as S,
+  vs as T,
+  Fs as _,
+  Y as a,
+  ds as b,
+  k as c,
+  K as d,
+  Rs as e,
+  ps as f,
+  At as g,
+  As as h,
+  Is as i,
+  ks as j,
+  Es as k,
+  Ms as l,
+  p as m,
+  b as n,
+  F as o,
+  xs as p,
+  w as q,
+  U as r,
+  j as s,
+  E as t,
+  Vn as u,
+  Ns as v
+};