@push.rocks/smartstate 2.0.9 → 2.0.10

package/dist_bundle/bundle.js

@@ -5685,6 +5685,1139 @@ var require_buffer_json = __commonJS({
   }
 });
 
+// node_modules/.pnpm/dayjs@1.11.9/node_modules/dayjs/dayjs.min.js
+var require_dayjs_min = __commonJS({
+  "node_modules/.pnpm/dayjs@1.11.9/node_modules/dayjs/dayjs.min.js"(exports, module) {
+    !function(t, e) {
+      "object" == typeof exports && "undefined" != typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs = e();
+    }(exports, function() {
+      "use strict";
+      var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", c = "month", f = "quarter", h = "year", d = "date", l = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = { name: "en", weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), ordinal: function(t2) {
+        var e2 = ["th", "st", "nd", "rd"], n2 = t2 % 100;
+        return "[" + t2 + (e2[(n2 - 20) % 10] || e2[n2] || e2[0]) + "]";
+      } }, m = function(t2, e2, n2) {
+        var r2 = String(t2);
+        return !r2 || r2.length >= e2 ? t2 : "" + Array(e2 + 1 - r2.length).join(n2) + t2;
+      }, v = { s: m, z: function(t2) {
+        var e2 = -t2.utcOffset(), n2 = Math.abs(e2), r2 = Math.floor(n2 / 60), i2 = n2 % 60;
+        return (e2 <= 0 ? "+" : "-") + m(r2, 2, "0") + ":" + m(i2, 2, "0");
+      }, m: function t2(e2, n2) {
+        if (e2.date() < n2.date())
+          return -t2(n2, e2);
+        var r2 = 12 * (n2.year() - e2.year()) + (n2.month() - e2.month()), i2 = e2.clone().add(r2, c), s2 = n2 - i2 < 0, u2 = e2.clone().add(r2 + (s2 ? -1 : 1), c);
+        return +(-(r2 + (n2 - i2) / (s2 ? i2 - u2 : u2 - i2)) || 0);
+      }, a: function(t2) {
+        return t2 < 0 ? Math.ceil(t2) || 0 : Math.floor(t2);
+      }, p: function(t2) {
+        return { M: c, y: h, w: o, d: a, D: d, h: u, m: s, s: i, ms: r, Q: f }[t2] || String(t2 || "").toLowerCase().replace(/s$/, "");
+      }, u: function(t2) {
+        return void 0 === t2;
+      } }, g = "en", D = {};
+      D[g] = M;
+      var p = function(t2) {
+        return t2 instanceof b;
+      }, S = function t2(e2, n2, r2) {
+        var i2;
+        if (!e2)
+          return g;
+        if ("string" == typeof e2) {
+          var s2 = e2.toLowerCase();
+          D[s2] && (i2 = s2), n2 && (D[s2] = n2, i2 = s2);
+          var u2 = e2.split("-");
+          if (!i2 && u2.length > 1)
+            return t2(u2[0]);
+        } else {
+          var a2 = e2.name;
+          D[a2] = e2, i2 = a2;
+        }
+        return !r2 && i2 && (g = i2), i2 || !r2 && g;
+      }, w = function(t2, e2) {
+        if (p(t2))
+          return t2.clone();
+        var n2 = "object" == typeof e2 ? e2 : {};
+        return n2.date = t2, n2.args = arguments, new b(n2);
+      }, O = v;
+      O.l = S, O.i = p, O.w = function(t2, e2) {
+        return w(t2, { locale: e2.$L, utc: e2.$u, x: e2.$x, $offset: e2.$offset });
+      };
+      var b = function() {
+        function M2(t2) {
+          this.$L = S(t2.locale, null, true), this.parse(t2);
+        }
+        var m2 = M2.prototype;
+        return m2.parse = function(t2) {
+          this.$d = function(t3) {
+            var e2 = t3.date, n2 = t3.utc;
+            if (null === e2)
+              return /* @__PURE__ */ new Date(NaN);
+            if (O.u(e2))
+              return /* @__PURE__ */ new Date();
+            if (e2 instanceof Date)
+              return new Date(e2);
+            if ("string" == typeof e2 && !/Z$/i.test(e2)) {
+              var r2 = e2.match($);
+              if (r2) {
+                var i2 = r2[2] - 1 || 0, s2 = (r2[7] || "0").substring(0, 3);
+                return n2 ? new Date(Date.UTC(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2)) : new Date(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2);
+              }
+            }
+            return new Date(e2);
+          }(t2), this.$x = t2.x || {}, this.init();
+        }, m2.init = function() {
+          var t2 = this.$d;
+          this.$y = t2.getFullYear(), this.$M = t2.getMonth(), this.$D = t2.getDate(), this.$W = t2.getDay(), this.$H = t2.getHours(), this.$m = t2.getMinutes(), this.$s = t2.getSeconds(), this.$ms = t2.getMilliseconds();
+        }, m2.$utils = function() {
+          return O;
+        }, m2.isValid = function() {
+          return !(this.$d.toString() === l);
+        }, m2.isSame = function(t2, e2) {
+          var n2 = w(t2);
+          return this.startOf(e2) <= n2 && n2 <= this.endOf(e2);
+        }, m2.isAfter = function(t2, e2) {
+          return w(t2) < this.startOf(e2);
+        }, m2.isBefore = function(t2, e2) {
+          return this.endOf(e2) < w(t2);
+        }, m2.$g = function(t2, e2, n2) {
+          return O.u(t2) ? this[e2] : this.set(n2, t2);
+        }, m2.unix = function() {
+          return Math.floor(this.valueOf() / 1e3);
+        }, m2.valueOf = function() {
+          return this.$d.getTime();
+        }, m2.startOf = function(t2, e2) {
+          var n2 = this, r2 = !!O.u(e2) || e2, f2 = O.p(t2), l2 = function(t3, e3) {
+            var i2 = O.w(n2.$u ? Date.UTC(n2.$y, e3, t3) : new Date(n2.$y, e3, t3), n2);
+            return r2 ? i2 : i2.endOf(a);
+          }, $2 = function(t3, e3) {
+            return O.w(n2.toDate()[t3].apply(n2.toDate("s"), (r2 ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e3)), n2);
+          }, y2 = this.$W, M3 = this.$M, m3 = this.$D, v2 = "set" + (this.$u ? "UTC" : "");
+          switch (f2) {
+            case h:
+              return r2 ? l2(1, 0) : l2(31, 11);
+            case c:
+              return r2 ? l2(1, M3) : l2(0, M3 + 1);
+            case o:
+              var g2 = this.$locale().weekStart || 0, D2 = (y2 < g2 ? y2 + 7 : y2) - g2;
+              return l2(r2 ? m3 - D2 : m3 + (6 - D2), M3);
+            case a:
+            case d:
+              return $2(v2 + "Hours", 0);
+            case u:
+              return $2(v2 + "Minutes", 1);
+            case s:
+              return $2(v2 + "Seconds", 2);
+            case i:
+              return $2(v2 + "Milliseconds", 3);
+            default:
+              return this.clone();
+          }
+        }, m2.endOf = function(t2) {
+          return this.startOf(t2, false);
+        }, m2.$set = function(t2, e2) {
+          var n2, o2 = O.p(t2), f2 = "set" + (this.$u ? "UTC" : ""), l2 = (n2 = {}, n2[a] = f2 + "Date", n2[d] = f2 + "Date", n2[c] = f2 + "Month", n2[h] = f2 + "FullYear", n2[u] = f2 + "Hours", n2[s] = f2 + "Minutes", n2[i] = f2 + "Seconds", n2[r] = f2 + "Milliseconds", n2)[o2], $2 = o2 === a ? this.$D + (e2 - this.$W) : e2;
+          if (o2 === c || o2 === h) {
+            var y2 = this.clone().set(d, 1);
+            y2.$d[l2]($2), y2.init(), this.$d = y2.set(d, Math.min(this.$D, y2.daysInMonth())).$d;
+          } else
+            l2 && this.$d[l2]($2);
+          return this.init(), this;
+        }, m2.set = function(t2, e2) {
+          return this.clone().$set(t2, e2);
+        }, m2.get = function(t2) {
+          return this[O.p(t2)]();
+        }, m2.add = function(r2, f2) {
+          var d2, l2 = this;
+          r2 = Number(r2);
+          var $2 = O.p(f2), y2 = function(t2) {
+            var e2 = w(l2);
+            return O.w(e2.date(e2.date() + Math.round(t2 * r2)), l2);
+          };
+          if ($2 === c)
+            return this.set(c, this.$M + r2);
+          if ($2 === h)
+            return this.set(h, this.$y + r2);
+          if ($2 === a)
+            return y2(1);
+          if ($2 === o)
+            return y2(7);
+          var M3 = (d2 = {}, d2[s] = e, d2[u] = n, d2[i] = t, d2)[$2] || 1, m3 = this.$d.getTime() + r2 * M3;
+          return O.w(m3, this);
+        }, m2.subtract = function(t2, e2) {
+          return this.add(-1 * t2, e2);
+        }, m2.format = function(t2) {
+          var e2 = this, n2 = this.$locale();
+          if (!this.isValid())
+            return n2.invalidDate || l;
+          var r2 = t2 || "YYYY-MM-DDTHH:mm:ssZ", i2 = O.z(this), s2 = this.$H, u2 = this.$m, a2 = this.$M, o2 = n2.weekdays, c2 = n2.months, f2 = n2.meridiem, h2 = function(t3, n3, i3, s3) {
+            return t3 && (t3[n3] || t3(e2, r2)) || i3[n3].slice(0, s3);
+          }, d2 = function(t3) {
+            return O.s(s2 % 12 || 12, t3, "0");
+          }, $2 = f2 || function(t3, e3, n3) {
+            var r3 = t3 < 12 ? "AM" : "PM";
+            return n3 ? r3.toLowerCase() : r3;
+          };
+          return r2.replace(y, function(t3, r3) {
+            return r3 || function(t4) {
+              switch (t4) {
+                case "YY":
+                  return String(e2.$y).slice(-2);
+                case "YYYY":
+                  return O.s(e2.$y, 4, "0");
+                case "M":
+                  return a2 + 1;
+                case "MM":
+                  return O.s(a2 + 1, 2, "0");
+                case "MMM":
+                  return h2(n2.monthsShort, a2, c2, 3);
+                case "MMMM":
+                  return h2(c2, a2);
+                case "D":
+                  return e2.$D;
+                case "DD":
+                  return O.s(e2.$D, 2, "0");
+                case "d":
+                  return String(e2.$W);
+                case "dd":
+                  return h2(n2.weekdaysMin, e2.$W, o2, 2);
+                case "ddd":
+                  return h2(n2.weekdaysShort, e2.$W, o2, 3);
+                case "dddd":
+                  return o2[e2.$W];
+                case "H":
+                  return String(s2);
+                case "HH":
+                  return O.s(s2, 2, "0");
+                case "h":
+                  return d2(1);
+                case "hh":
+                  return d2(2);
+                case "a":
+                  return $2(s2, u2, true);
+                case "A":
+                  return $2(s2, u2, false);
+                case "m":
+                  return String(u2);
+                case "mm":
+                  return O.s(u2, 2, "0");
+                case "s":
+                  return String(e2.$s);
+                case "ss":
+                  return O.s(e2.$s, 2, "0");
+                case "SSS":
+                  return O.s(e2.$ms, 3, "0");
+                case "Z":
+                  return i2;
+              }
+              return null;
+            }(t3) || i2.replace(":", "");
+          });
+        }, m2.utcOffset = function() {
+          return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+        }, m2.diff = function(r2, d2, l2) {
+          var $2, y2 = this, M3 = O.p(d2), m3 = w(r2), v2 = (m3.utcOffset() - this.utcOffset()) * e, g2 = this - m3, D2 = function() {
+            return O.m(y2, m3);
+          };
+          switch (M3) {
+            case h:
+              $2 = D2() / 12;
+              break;
+            case c:
+              $2 = D2();
+              break;
+            case f:
+              $2 = D2() / 3;
+              break;
+            case o:
+              $2 = (g2 - v2) / 6048e5;
+              break;
+            case a:
+              $2 = (g2 - v2) / 864e5;
+              break;
+            case u:
+              $2 = g2 / n;
+              break;
+            case s:
+              $2 = g2 / e;
+              break;
+            case i:
+              $2 = g2 / t;
+              break;
+            default:
+              $2 = g2;
+          }
+          return l2 ? $2 : O.a($2);
+        }, m2.daysInMonth = function() {
+          return this.endOf(c).$D;
+        }, m2.$locale = function() {
+          return D[this.$L];
+        }, m2.locale = function(t2, e2) {
+          if (!t2)
+            return this.$L;
+          var n2 = this.clone(), r2 = S(t2, e2, true);
+          return r2 && (n2.$L = r2), n2;
+        }, m2.clone = function() {
+          return O.w(this.$d, this);
+        }, m2.toDate = function() {
+          return new Date(this.valueOf());
+        }, m2.toJSON = function() {
+          return this.isValid() ? this.toISOString() : null;
+        }, m2.toISOString = function() {
+          return this.$d.toISOString();
+        }, m2.toString = function() {
+          return this.$d.toUTCString();
+        }, M2;
+      }(), _ = b.prototype;
+      return w.prototype = _, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", c], ["$y", h], ["$D", d]].forEach(function(t2) {
+        _[t2[1]] = function(e2) {
+          return this.$g(e2, t2[0], t2[1]);
+        };
+      }), w.extend = function(t2, e2) {
+        return t2.$i || (t2(e2, b, w), t2.$i = true), w;
+      }, w.locale = S, w.isDayjs = p, w.unix = function(t2) {
+        return w(1e3 * t2);
+      }, w.en = D[g], w.Ls = D, w.p = {}, w;
+    });
+  }
+});
+
+// node_modules/.pnpm/dayjs@1.11.9/node_modules/dayjs/plugin/isToday.js
+var require_isToday = __commonJS({
+  "node_modules/.pnpm/dayjs@1.11.9/node_modules/dayjs/plugin/isToday.js"(exports, module) {
+    !function(e, o) {
+      "object" == typeof exports && "undefined" != typeof module ? module.exports = o() : "function" == typeof define && define.amd ? define(o) : (e = "undefined" != typeof globalThis ? globalThis : e || self).dayjs_plugin_isToday = o();
+    }(exports, function() {
+      "use strict";
+      return function(e, o, t) {
+        o.prototype.isToday = function() {
+          var e2 = "YYYY-MM-DD", o2 = t();
+          return this.format(e2) === o2.format(e2);
+        };
+      };
+    });
+  }
+});
+
+// node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/SymbolTreeNode.js
+var require_SymbolTreeNode = __commonJS({
+  "node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/SymbolTreeNode.js"(exports, module) {
+    "use strict";
+    module.exports = class SymbolTreeNode {
+      constructor() {
+        this.parent = null;
+        this.previousSibling = null;
+        this.nextSibling = null;
+        this.firstChild = null;
+        this.lastChild = null;
+        this.childrenVersion = 0;
+        this.childIndexCachedUpTo = null;
+        this.cachedIndex = -1;
+        this.cachedIndexVersion = NaN;
+      }
+      get isAttached() {
+        return Boolean(this.parent || this.previousSibling || this.nextSibling);
+      }
+      get hasChildren() {
+        return Boolean(this.firstChild);
+      }
+      childrenChanged() {
+        this.childrenVersion = this.childrenVersion + 1 & 4294967295;
+        this.childIndexCachedUpTo = null;
+      }
+      getCachedIndex(parentNode) {
+        if (this.cachedIndexVersion !== parentNode.childrenVersion) {
+          this.cachedIndexVersion = NaN;
+          return -1;
+        }
+        return this.cachedIndex;
+      }
+      setCachedIndex(parentNode, index) {
+        this.cachedIndexVersion = parentNode.childrenVersion;
+        this.cachedIndex = index;
+      }
+    };
+  }
+});
+
+// node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/TreePosition.js
+var require_TreePosition = __commonJS({
+  "node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/TreePosition.js"(exports, module) {
+    "use strict";
+    module.exports = Object.freeze({
+      // same as DOM DOCUMENT_POSITION_
+      DISCONNECTED: 1,
+      PRECEDING: 2,
+      FOLLOWING: 4,
+      CONTAINS: 8,
+      CONTAINED_BY: 16
+    });
+  }
+});
+
+// node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/TreeIterator.js
+var require_TreeIterator = __commonJS({
+  "node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/TreeIterator.js"(exports, module) {
+    "use strict";
+    var TREE = Symbol();
+    var ROOT = Symbol();
+    var NEXT = Symbol();
+    var ITERATE_FUNC = Symbol();
+    var TreeIterator = class {
+      constructor(tree, root, firstResult, iterateFunction) {
+        this[TREE] = tree;
+        this[ROOT] = root;
+        this[NEXT] = firstResult;
+        this[ITERATE_FUNC] = iterateFunction;
+      }
+      next() {
+        const tree = this[TREE];
+        const iterateFunc = this[ITERATE_FUNC];
+        const root = this[ROOT];
+        if (!this[NEXT]) {
+          return {
+            done: true,
+            value: root
+          };
+        }
+        const value = this[NEXT];
+        if (iterateFunc === 1) {
+          this[NEXT] = tree._node(value).previousSibling;
+        } else if (iterateFunc === 2) {
+          this[NEXT] = tree._node(value).nextSibling;
+        } else if (iterateFunc === 3) {
+          this[NEXT] = tree._node(value).parent;
+        } else if (iterateFunc === 4) {
+          this[NEXT] = tree.preceding(value, { root });
+        } else {
+          this[NEXT] = tree.following(value, { root });
+        }
+        return {
+          done: false,
+          value
+        };
+      }
+    };
+    Object.defineProperty(TreeIterator.prototype, Symbol.iterator, {
+      value: function() {
+        return this;
+      },
+      writable: false
+    });
+    TreeIterator.PREV = 1;
+    TreeIterator.NEXT = 2;
+    TreeIterator.PARENT = 3;
+    TreeIterator.PRECEDING = 4;
+    TreeIterator.FOLLOWING = 5;
+    Object.freeze(TreeIterator);
+    Object.freeze(TreeIterator.prototype);
+    module.exports = TreeIterator;
+  }
+});
+
+// node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/SymbolTree.js
+var require_SymbolTree = __commonJS({
+  "node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/SymbolTree.js"(exports, module) {
+    "use strict";
+    var SymbolTreeNode = require_SymbolTreeNode();
+    var TreePosition = require_TreePosition();
+    var TreeIterator = require_TreeIterator();
+    function returnTrue() {
+      return true;
+    }
+    function reverseArrayIndex(array, reverseIndex) {
+      return array[array.length - 1 - reverseIndex];
+    }
+    var SymbolTree = class {
+      /**
+       * @constructor
+       * @alias module:symbol-tree
+       * @param {string} [description='SymbolTree data'] Description used for the Symbol
+       */
+      constructor(description) {
+        this.symbol = Symbol(description || "SymbolTree data");
+      }
+      /**
+       * You can use this function to (optionally) initialize an object right after its creation,
+       * to take advantage of V8's fast properties. Also useful if you would like to
+       * freeze your object.
+       *
+       * `O(1)`
+       *
+       * @method
+       * @alias module:symbol-tree#initialize
+       * @param {Object} object
+       * @return {Object} object
+       */
+      initialize(object) {
+        this._node(object);
+        return object;
+      }
+      _node(object) {
+        if (!object) {
+          return null;
+        }
+        const node = object[this.symbol];
+        if (node) {
+          return node;
+        }
+        return object[this.symbol] = new SymbolTreeNode();
+      }
+      /**
+       * Returns `true` if the object has any children. Otherwise it returns `false`.
+       *
+       * * `O(1)`
+       *
+       * @method hasChildren
+       * @memberOf module:symbol-tree#
+       * @param {Object} object
+       * @return {Boolean}
+       */
+      hasChildren(object) {
+        return this._node(object).hasChildren;
+      }
+      /**
+       * Returns the first child of the given object.
+       *
+       * * `O(1)`
+       *
+       * @method firstChild
+       * @memberOf module:symbol-tree#
+       * @param {Object} object
+       * @return {Object}
+       */
+      firstChild(object) {
+        return this._node(object).firstChild;
+      }
+      /**
+       * Returns the last child of the given object.
+       *
+       * * `O(1)`
+       *
+       * @method lastChild
+       * @memberOf module:symbol-tree#
+       * @param {Object} object
+       * @return {Object}
+       */
+      lastChild(object) {
+        return this._node(object).lastChild;
+      }
+      /**
+       * Returns the previous sibling of the given object.
+       *
+       * * `O(1)`
+       *
+       * @method previousSibling
+       * @memberOf module:symbol-tree#
+       * @param {Object} object
+       * @return {Object}
+       */
+      previousSibling(object) {
+        return this._node(object).previousSibling;
+      }
+      /**
+       * Returns the next sibling of the given object.
+       *
+       * * `O(1)`
+       *
+       * @method nextSibling
+       * @memberOf module:symbol-tree#
+       * @param {Object} object
+       * @return {Object}
+       */
+      nextSibling(object) {
+        return this._node(object).nextSibling;
+      }
+      /**
+       * Return the parent of the given object.
+       *
+       * * `O(1)`
+       *
+       * @method parent
+       * @memberOf module:symbol-tree#
+       * @param {Object} object
+       * @return {Object}
+       */
+      parent(object) {
+        return this._node(object).parent;
+      }
+      /**
+       * Find the inclusive descendant that is last in tree order of the given object.
+       *
+       * * `O(n)` (worst case) where `n` is the depth of the subtree of `object`
+       *
+       * @method lastInclusiveDescendant
+       * @memberOf module:symbol-tree#
+       * @param {Object} object
+       * @return {Object}
+       */
+      lastInclusiveDescendant(object) {
+        let lastChild;
+        let current = object;
+        while (lastChild = this._node(current).lastChild) {
+          current = lastChild;
+        }
+        return current;
+      }
+      /**
+       * Find the preceding object (A) of the given object (B).
+       * An object A is preceding an object B if A and B are in the same tree
+       * and A comes before B in tree order.
+       *
+       * * `O(n)` (worst case)
+       * * `O(1)` (amortized when walking the entire tree)
+       *
+       * @method preceding
+       * @memberOf module:symbol-tree#
+       * @param {Object} object
+       * @param {Object} [options]
+       * @param {Object} [options.root] If set, `root` must be an inclusive ancestor
+       *        of the return value (or else null is returned). This check _assumes_
+       *        that `root` is also an inclusive ancestor of the given `object`
+       * @return {?Object}
+       */
+      preceding(object, options) {
+        const treeRoot = options && options.root;
+        if (object === treeRoot) {
+          return null;
+        }
+        const previousSibling = this._node(object).previousSibling;
+        if (previousSibling) {
+          return this.lastInclusiveDescendant(previousSibling);
+        }
+        return this._node(object).parent;
+      }
+      /**
+       * Find the following object (A) of the given object (B).
+       * An object A is following an object B if A and B are in the same tree
+       * and A comes after B in tree order.
+       *
+       * * `O(n)` (worst case) where `n` is the amount of objects in the entire tree
+       * * `O(1)` (amortized when walking the entire tree)
+       *
+       * @method following
+       * @memberOf module:symbol-tree#
+       * @param {!Object} object
+       * @param {Object} [options]
+       * @param {Object} [options.root] If set, `root` must be an inclusive ancestor
+       *        of the return value (or else null is returned). This check _assumes_
+       *        that `root` is also an inclusive ancestor of the given `object`
+       * @param {Boolean} [options.skipChildren=false] If set, ignore the children of `object`
+       * @return {?Object}
+       */
+      following(object, options) {
+        const treeRoot = options && options.root;
+        const skipChildren = options && options.skipChildren;
+        const firstChild = !skipChildren && this._node(object).firstChild;
+        if (firstChild) {
+          return firstChild;
+        }
+        let current = object;
+        do {
+          if (current === treeRoot) {
+            return null;
+          }
+          const nextSibling = this._node(current).nextSibling;
+          if (nextSibling) {
+            return nextSibling;
+          }
+          current = this._node(current).parent;
+        } while (current);
+        return null;
+      }
+      /**
+       * Append all children of the given object to an array.
+       *
+       * * `O(n)` where `n` is the amount of children of the given `parent`
+       *
+       * @method childrenToArray
+       * @memberOf module:symbol-tree#
+       * @param {Object} parent
+       * @param {Object} [options]
+       * @param {Object[]} [options.array=[]]
+       * @param {Function} [options.filter] Function to test each object before it is added to the array.
+       *                            Invoked with arguments (object). Should return `true` if an object
+       *                            is to be included.
+       * @param {*} [options.thisArg] Value to use as `this` when executing `filter`.
+       * @return {Object[]}
+       */
+      childrenToArray(parent, options) {
+        const array = options && options.array || [];
+        const filter2 = options && options.filter || returnTrue;
+        const thisArg = options && options.thisArg || void 0;
+        const parentNode = this._node(parent);
+        let object = parentNode.firstChild;
+        let index = 0;
+        while (object) {
+          const node = this._node(object);
+          node.setCachedIndex(parentNode, index);
+          if (filter2.call(thisArg, object)) {
+            array.push(object);
+          }
+          object = node.nextSibling;
+          ++index;
+        }
+        return array;
+      }
+      /**
+       * Append all inclusive ancestors of the given object to an array.
+       *
+       * * `O(n)` where `n` is the amount of ancestors of the given `object`
+       *
+       * @method ancestorsToArray
+       * @memberOf module:symbol-tree#
+       * @param {Object} object
+       * @param {Object} [options]
+       * @param {Object[]} [options.array=[]]
+       * @param {Function} [options.filter] Function to test each object before it is added to the array.
+       *                            Invoked with arguments (object). Should return `true` if an object
+       *                            is to be included.
+       * @param {*} [options.thisArg] Value to use as `this` when executing `filter`.
+       * @return {Object[]}
+       */
+      ancestorsToArray(object, options) {
+        const array = options && options.array || [];
+        const filter2 = options && options.filter || returnTrue;
+        const thisArg = options && options.thisArg || void 0;
+        let ancestor = object;
+        while (ancestor) {
+          if (filter2.call(thisArg, ancestor)) {
+            array.push(ancestor);
+          }
+          ancestor = this._node(ancestor).parent;
+        }
+        return array;
+      }
+      /**
+       * Append all descendants of the given object to an array (in tree order).
+       *
+       * * `O(n)` where `n` is the amount of objects in the sub-tree of the given `object`
+       *
+       * @method treeToArray
+       * @memberOf module:symbol-tree#
+       * @param {Object} root
+       * @param {Object} [options]
+       * @param {Object[]} [options.array=[]]
+       * @param {Function} [options.filter] Function to test each object before it is added to the array.
+       *                            Invoked with arguments (object). Should return `true` if an object
+       *                            is to be included.
+       * @param {*} [options.thisArg] Value to use as `this` when executing `filter`.
+       * @return {Object[]}
+       */
+      treeToArray(root, options) {
+        const array = options && options.array || [];
+        const filter2 = options && options.filter || returnTrue;
+        const thisArg = options && options.thisArg || void 0;
+        let object = root;
+        while (object) {
+          if (filter2.call(thisArg, object)) {
+            array.push(object);
+          }
+          object = this.following(object, { root });
+        }
+        return array;
+      }
+      /**
+       * Iterate over all children of the given object
+       *
+       * * `O(1)` for a single iteration
+       *
+       * @method childrenIterator
+       * @memberOf module:symbol-tree#
+       * @param {Object} parent
+       * @param {Object} [options]
+       * @param {Boolean} [options.reverse=false]
+       * @return {Object} An iterable iterator (ES6)
+       */
+      childrenIterator(parent, options) {
+        const reverse = options && options.reverse;
+        const parentNode = this._node(parent);
+        return new TreeIterator(
+          this,
+          parent,
+          reverse ? parentNode.lastChild : parentNode.firstChild,
+          reverse ? TreeIterator.PREV : TreeIterator.NEXT
+        );
+      }
+      /**
+       * Iterate over all the previous siblings of the given object. (in reverse tree order)
+       *
+       * * `O(1)` for a single iteration
+       *
+       * @method previousSiblingsIterator
+       * @memberOf module:symbol-tree#
+       * @param {Object} object
+       * @return {Object} An iterable iterator (ES6)
+       */
+      previousSiblingsIterator(object) {
+        return new TreeIterator(
+          this,
+          object,
+          this._node(object).previousSibling,
+          TreeIterator.PREV
+        );
+      }
+      /**
+       * Iterate over all the next siblings of the given object. (in tree order)
+       *
+       * * `O(1)` for a single iteration
+       *
+       * @method nextSiblingsIterator
+       * @memberOf module:symbol-tree#
+       * @param {Object} object
+       * @return {Object} An iterable iterator (ES6)
+       */
+      nextSiblingsIterator(object) {
+        return new TreeIterator(
+          this,
+          object,
+          this._node(object).nextSibling,
+          TreeIterator.NEXT
+        );
+      }
+      /**
+       * Iterate over all inclusive ancestors of the given object
+       *
+       * * `O(1)` for a single iteration
+       *
+       * @method ancestorsIterator
+       * @memberOf module:symbol-tree#
+       * @param {Object} object
+       * @return {Object} An iterable iterator (ES6)
+       */
+      ancestorsIterator(object) {
+        return new TreeIterator(
+          this,
+          object,
+          object,
+          TreeIterator.PARENT
+        );
+      }
+      /**
+       * Iterate over all descendants of the given object (in tree order).
+       *
+       * Where `n` is the amount of objects in the sub-tree of the given `root`:
+       *
+       * * `O(n)` (worst case for a single iteration)
+       * * `O(n)` (amortized, when completing the iterator)
+       *
+       * @method treeIterator
+       * @memberOf module:symbol-tree#
+       * @param {Object} root
+       * @param {Object} options
+       * @param {Boolean} [options.reverse=false]
+       * @return {Object} An iterable iterator (ES6)
+       */
+      treeIterator(root, options) {
+        const reverse = options && options.reverse;
+        return new TreeIterator(
+          this,
+          root,
+          reverse ? this.lastInclusiveDescendant(root) : root,
+          reverse ? TreeIterator.PRECEDING : TreeIterator.FOLLOWING
+        );
+      }
+      /**
+       * Find the index of the given object (the number of preceding siblings).
+       *
+       * * `O(n)` where `n` is the amount of preceding siblings
+       * * `O(1)` (amortized, if the tree is not modified)
+       *
+       * @method index
+       * @memberOf module:symbol-tree#
+       * @param {Object} child
+       * @return {Number} The number of preceding siblings, or -1 if the object has no parent
+       */
+      index(child) {
+        const childNode = this._node(child);
+        const parentNode = this._node(childNode.parent);
+        if (!parentNode) {
+          return -1;
+        }
+        let currentIndex = childNode.getCachedIndex(parentNode);
+        if (currentIndex >= 0) {
+          return currentIndex;
+        }
+        currentIndex = 0;
+        let object = parentNode.firstChild;
+        if (parentNode.childIndexCachedUpTo) {
+          const cachedUpToNode = this._node(parentNode.childIndexCachedUpTo);
+          object = cachedUpToNode.nextSibling;
+          currentIndex = cachedUpToNode.getCachedIndex(parentNode) + 1;
+        }
+        while (object) {
+          const node = this._node(object);
+          node.setCachedIndex(parentNode, currentIndex);
+          if (object === child) {
+            break;
+          }
+          ++currentIndex;
+          object = node.nextSibling;
+        }
+        parentNode.childIndexCachedUpTo = child;
+        return currentIndex;
+      }
+      /**
+       * Calculate the number of children.
+       *
+       * * `O(n)` where `n` is the amount of children
+       * * `O(1)` (amortized, if the tree is not modified)
+       *
+       * @method childrenCount
+       * @memberOf module:symbol-tree#
+       * @param {Object} parent
+       * @return {Number}
+       */
+      childrenCount(parent) {
+        const parentNode = this._node(parent);
+        if (!parentNode.lastChild) {
+          return 0;
+        }
+        return this.index(parentNode.lastChild) + 1;
+      }
+      /**
+       * Compare the position of an object relative to another object. A bit set is returned:
+       *
+       * <ul>
+       *     <li>DISCONNECTED : 1</li>
+       *     <li>PRECEDING : 2</li>
+       *     <li>FOLLOWING : 4</li>
+       *     <li>CONTAINS : 8</li>
+       *     <li>CONTAINED_BY : 16</li>
+       * </ul>
+       *
+       * The semantics are the same as compareDocumentPosition in DOM, with the exception that
+       * DISCONNECTED never occurs with any other bit.
+       *
+       * where `n` and `m` are the amount of ancestors of `left` and `right`;
+       * where `o` is the amount of children of the lowest common ancestor of `left` and `right`:
+       *
+       * * `O(n + m + o)` (worst case)
+       * * `O(n + m)` (amortized, if the tree is not modified)
+       *
+       * @method compareTreePosition
+       * @memberOf module:symbol-tree#
+       * @param {Object} left
+       * @param {Object} right
+       * @return {Number}
+       */
+      compareTreePosition(left, right) {
+        if (left === right) {
+          return 0;
+        }
+        const leftAncestors = [];
+        {
+          let leftAncestor = left;
+          while (leftAncestor) {
+            if (leftAncestor === right) {
+              return TreePosition.CONTAINS | TreePosition.PRECEDING;
+            }
+            leftAncestors.push(leftAncestor);
+            leftAncestor = this.parent(leftAncestor);
+          }
+        }
+        const rightAncestors = [];
+        {
+          let rightAncestor = right;
+          while (rightAncestor) {
+            if (rightAncestor === left) {
+              return TreePosition.CONTAINED_BY | TreePosition.FOLLOWING;
+            }
+            rightAncestors.push(rightAncestor);
+            rightAncestor = this.parent(rightAncestor);
+          }
+        }
+        const root = reverseArrayIndex(leftAncestors, 0);
+        if (!root || root !== reverseArrayIndex(rightAncestors, 0)) {
+          return TreePosition.DISCONNECTED;
+        }
+        let commonAncestorIndex = 0;
+        const ancestorsMinLength = Math.min(leftAncestors.length, rightAncestors.length);
+        for (let i = 0; i < ancestorsMinLength; ++i) {
+          const leftAncestor = reverseArrayIndex(leftAncestors, i);
+          const rightAncestor = reverseArrayIndex(rightAncestors, i);
+          if (leftAncestor !== rightAncestor) {
+            break;
+          }
+          commonAncestorIndex = i;
+        }
+        const leftIndex = this.index(reverseArrayIndex(leftAncestors, commonAncestorIndex + 1));
+        const rightIndex = this.index(reverseArrayIndex(rightAncestors, commonAncestorIndex + 1));
+        return rightIndex < leftIndex ? TreePosition.PRECEDING : TreePosition.FOLLOWING;
+      }
+      /**
+       * Remove the object from this tree.
+       * Has no effect if already removed.
+       *
+       * * `O(1)`
+       *
+       * @method remove
+       * @memberOf module:symbol-tree#
+       * @param {Object} removeObject
+       * @return {Object} removeObject
+       */
+      remove(removeObject) {
+        const removeNode = this._node(removeObject);
+        const parentNode = this._node(removeNode.parent);
+        const prevNode = this._node(removeNode.previousSibling);
+        const nextNode = this._node(removeNode.nextSibling);
+        if (parentNode) {
+          if (parentNode.firstChild === removeObject) {
+            parentNode.firstChild = removeNode.nextSibling;
+          }
+          if (parentNode.lastChild === removeObject) {
+            parentNode.lastChild = removeNode.previousSibling;
+          }
+        }
+        if (prevNode) {
+          prevNode.nextSibling = removeNode.nextSibling;
+        }
+        if (nextNode) {
+          nextNode.previousSibling = removeNode.previousSibling;
+        }
+        removeNode.parent = null;
+        removeNode.previousSibling = null;
+        removeNode.nextSibling = null;
+        removeNode.cachedIndex = -1;
+        removeNode.cachedIndexVersion = NaN;
+        if (parentNode) {
+          parentNode.childrenChanged();
+        }
+        return removeObject;
+      }
+      /**
+       * Insert the given object before the reference object.
+       * `newObject` is now the previous sibling of `referenceObject`.
+       *
+       * * `O(1)`
+       *
+       * @method insertBefore
+       * @memberOf module:symbol-tree#
+       * @param {Object} referenceObject
+       * @param {Object} newObject
+       * @throws {Error} If the newObject is already present in this SymbolTree
+       * @return {Object} newObject
+       */
+      insertBefore(referenceObject, newObject) {
+        const referenceNode = this._node(referenceObject);
+        const prevNode = this._node(referenceNode.previousSibling);
+        const newNode = this._node(newObject);
+        const parentNode = this._node(referenceNode.parent);
+        if (newNode.isAttached) {
+          throw Error("Given object is already present in this SymbolTree, remove it first");
+        }
+        newNode.parent = referenceNode.parent;
+        newNode.previousSibling = referenceNode.previousSibling;
+        newNode.nextSibling = referenceObject;
+        referenceNode.previousSibling = newObject;
+        if (prevNode) {
+          prevNode.nextSibling = newObject;
+        }
+        if (parentNode && parentNode.firstChild === referenceObject) {
+          parentNode.firstChild = newObject;
+        }
+        if (parentNode) {
+          parentNode.childrenChanged();
+        }
+        return newObject;
+      }
+      /**
+       * Insert the given object after the reference object.
+       * `newObject` is now the next sibling of `referenceObject`.
+       *
+       * * `O(1)`
+       *
+       * @method insertAfter
+       * @memberOf module:symbol-tree#
+       * @param {Object} referenceObject
+       * @param {Object} newObject
+       * @throws {Error} If the newObject is already present in this SymbolTree
+       * @return {Object} newObject
+       */
+      insertAfter(referenceObject, newObject) {
+        const referenceNode = this._node(referenceObject);
+        const nextNode = this._node(referenceNode.nextSibling);
+        const newNode = this._node(newObject);
+        const parentNode = this._node(referenceNode.parent);
+        if (newNode.isAttached) {
+          throw Error("Given object is already present in this SymbolTree, remove it first");
+        }
+        newNode.parent = referenceNode.parent;
+        newNode.previousSibling = referenceObject;
+        newNode.nextSibling = referenceNode.nextSibling;
+        referenceNode.nextSibling = newObject;
+        if (nextNode) {
+          nextNode.previousSibling = newObject;
+        }
+        if (parentNode && parentNode.lastChild === referenceObject) {
+          parentNode.lastChild = newObject;
+        }
+        if (parentNode) {
+          parentNode.childrenChanged();
+        }
+        return newObject;
+      }
+      /**
+       * Insert the given object as the first child of the given reference object.
+       * `newObject` is now the first child of `referenceObject`.
+       *
+       * * `O(1)`
+       *
+       * @method prependChild
+       * @memberOf module:symbol-tree#
+       * @param {Object} referenceObject
+       * @param {Object} newObject
+       * @throws {Error} If the newObject is already present in this SymbolTree
+       * @return {Object} newObject
+       */
+      prependChild(referenceObject, newObject) {
+        const referenceNode = this._node(referenceObject);
+        const newNode = this._node(newObject);
+        if (newNode.isAttached) {
+          throw Error("Given object is already present in this SymbolTree, remove it first");
+        }
+        if (referenceNode.hasChildren) {
+          this.insertBefore(referenceNode.firstChild, newObject);
+        } else {
+          newNode.parent = referenceObject;
+          referenceNode.firstChild = newObject;
+          referenceNode.lastChild = newObject;
+          referenceNode.childrenChanged();
+        }
+        return newObject;
+      }
+      /**
+       * Insert the given object as the last child of the given reference object.
+       * `newObject` is now the last child of `referenceObject`.
+       *
+       * * `O(1)`
+       *
+       * @method appendChild
+       * @memberOf module:symbol-tree#
+       * @param {Object} referenceObject
+       * @param {Object} newObject
+       * @throws {Error} If the newObject is already present in this SymbolTree
+       * @return {Object} newObject
+       */
+      appendChild(referenceObject, newObject) {
+        const referenceNode = this._node(referenceObject);
+        const newNode = this._node(newObject);
+        if (newNode.isAttached) {
+          throw Error("Given object is already present in this SymbolTree, remove it first");
+        }
+        if (referenceNode.hasChildren) {
+          this.insertAfter(referenceNode.lastChild, newObject);
+        } else {
+          newNode.parent = referenceObject;
+          referenceNode.firstChild = newObject;
+          referenceNode.lastChild = newObject;
+          referenceNode.childrenChanged();
+        }
+        return newObject;
+      }
+    };
+    module.exports = SymbolTree;
+    SymbolTree.TreePosition = TreePosition;
+  }
+});
+
 // node_modules/.pnpm/@push.rocks+isohash@2.0.1/node_modules/@push.rocks/isohash/dist_ts/index.js
 var dist_ts_exports2 = {};
 __export(dist_ts_exports2, {
@@ -5881,6 +7014,12 @@ __export(smartstring_create_exports, {
   createRandomString: () => createRandomString
 });
 
+// node_modules/.pnpm/@push.rocks+smartenv@5.0.5/node_modules/@push.rocks/smartenv/dist_ts/index.js
+var dist_ts_exports3 = {};
+__export(dist_ts_exports3, {
+  Smartenv: () => Smartenv2
+});
+
 // node_modules/.pnpm/@push.rocks+smartenv@5.0.5/node_modules/@push.rocks/smartenv/dist_ts/smartenv.plugins.js
 var smartpromise2 = __toESM(require_dist_ts(), 1);
 
@@ -8960,6 +10099,955 @@ var ObservableIntake = class {
   }
 };
 
+// node_modules/.pnpm/@push.rocks+webstore@2.0.13/node_modules/@push.rocks/webstore/dist_ts/index.js
+var dist_ts_exports13 = {};
+__export(dist_ts_exports13, {
+  TypedrequestCache: () => TypedrequestCache,
+  WebStore: () => WebStore
+});
+
+// node_modules/.pnpm/croner@5.7.0/node_modules/croner/dist/croner.min.mjs
+function minitz(y, m, d, h, i, s, tz, throwOnInvalid) {
+  return minitz.fromTZ(minitz.tp(y, m, d, h, i, s, tz), throwOnInvalid);
+}
+minitz.fromTZISO = (localTimeStr, tz, throwOnInvalid) => {
+  return minitz.fromTZ(parseISOLocal(localTimeStr, tz), throwOnInvalid);
+};
+minitz.fromTZ = function(tp, throwOnInvalid) {
+  const inDate = new Date(Date.UTC(tp.y, tp.m - 1, tp.d, tp.h, tp.i, tp.s)), offset = getTimezoneOffset(tp.tz, inDate), dateGuess = new Date(inDate.getTime() - offset), dateOffsGuess = getTimezoneOffset(tp.tz, dateGuess);
+  if (dateOffsGuess - offset === 0) {
+    return dateGuess;
+  } else {
+    const dateGuess2 = new Date(inDate.getTime() - dateOffsGuess), dateOffsGuess2 = getTimezoneOffset(tp.tz, dateGuess2);
+    if (dateOffsGuess2 - dateOffsGuess === 0) {
+      return dateGuess2;
+    } else if (!throwOnInvalid && dateOffsGuess2 - dateOffsGuess > 0) {
+      return dateGuess2;
+    } else if (!throwOnInvalid) {
+      return dateGuess;
+    } else {
+      throw new Error("Invalid date passed to fromTZ()");
+    }
+  }
+};
+minitz.toTZ = function(d, tzStr) {
+  const td = new Date(d.toLocaleString("sv-SE", { timeZone: tzStr }));
+  return { y: td.getFullYear(), m: td.getMonth() + 1, d: td.getDate(), h: td.getHours(), i: td.getMinutes(), s: td.getSeconds(), tz: tzStr };
+};
+minitz.tp = (y, m, d, h, i, s, tz) => {
+  return { y, m, d, h, i, s, tz };
+};
+function getTimezoneOffset(timeZone, date = /* @__PURE__ */ new Date()) {
+  const tz = date.toLocaleString("en", { timeZone, timeStyle: "long" }).split(" ").slice(-1)[0];
+  const dateString = date.toLocaleString("en-US").replace(/[\u202f]/, " ");
+  return Date.parse(`${dateString} GMT`) - Date.parse(`${dateString} ${tz}`);
+}
+function parseISOLocal(dtStr, tz) {
+  const pd = new Date(Date.parse(dtStr));
+  if (isNaN(pd)) {
+    throw new Error("minitz: Invalid ISO8601 passed to parser.");
+  }
+  const stringEnd = dtStr.substring(9);
+  if (dtStr.includes("Z") || stringEnd.includes("-") || stringEnd.includes("+")) {
+    return minitz.tp(pd.getUTCFullYear(), pd.getUTCMonth() + 1, pd.getUTCDate(), pd.getUTCHours(), pd.getUTCMinutes(), pd.getUTCSeconds(), "Etc/UTC");
+  } else {
+    return minitz.tp(pd.getFullYear(), pd.getMonth() + 1, pd.getDate(), pd.getHours(), pd.getMinutes(), pd.getSeconds(), tz);
+  }
+}
+minitz.minitz = minitz;
+function CronOptions(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  delete options.name;
+  options.legacyMode = options.legacyMode === void 0 ? true : options.legacyMode;
+  options.paused = options.paused === void 0 ? false : options.paused;
+  options.maxRuns = options.maxRuns === void 0 ? Infinity : options.maxRuns;
+  options.catch = options.catch === void 0 ? false : options.catch;
+  options.interval = options.interval === void 0 ? 0 : parseInt(options.interval, 10);
+  options.utcOffset = options.utcOffset === void 0 ? void 0 : parseInt(options.utcOffset, 10);
+  options.unref = options.unref === void 0 ? false : options.unref;
+  options.kill = false;
+  if (options.startAt) {
+    options.startAt = new CronDate(options.startAt, options.timezone);
+  }
+  if (options.stopAt) {
+    options.stopAt = new CronDate(options.stopAt, options.timezone);
+  }
+  if (options.interval !== null) {
+    if (isNaN(options.interval)) {
+      throw new Error("CronOptions: Supplied value for interval is not a number");
+    } else if (options.interval < 0) {
+      throw new Error("CronOptions: Supplied value for interval can not be negative");
+    }
+  }
+  if (options.utcOffset !== void 0) {
+    if (isNaN(options.utcOffset)) {
+      throw new Error("CronOptions: Invalid value passed for utcOffset, should be number representing minutes offset from UTC.");
+    } else if (options.utcOffset < -870 || options.utcOffset > 870) {
+      throw new Error("CronOptions: utcOffset out of bounds.");
+    }
+    if (options.utcOffset !== void 0 && options.timezone) {
+      throw new Error("CronOptions: Combining 'utcOffset' with 'timezone' is not allowed.");
+    }
+  }
+  if (options.unref !== true && options.unref !== false) {
+    throw new Error("CronOptions: Unref should be either true, false or undefined(false).");
+  }
+  return options;
+}
+var DaysOfMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+var RecursionSteps = [["month", "year", 0], ["day", "month", -1], ["hour", "day", 0], ["minute", "hour", 0], ["second", "minute", 0]];
+function CronDate(d, tz) {
+  this.tz = tz;
+  if (d && d instanceof Date) {
+    if (!isNaN(d)) {
+      this.fromDate(d);
+    } else {
+      throw new TypeError("CronDate: Invalid date passed to CronDate constructor");
+    }
+  } else if (d === void 0) {
+    this.fromDate(/* @__PURE__ */ new Date());
+  } else if (d && typeof d === "string") {
+    this.fromString(d);
+  } else if (d instanceof CronDate) {
+    this.fromCronDate(d);
+  } else {
+    throw new TypeError("CronDate: Invalid type (" + typeof d + ") passed to CronDate constructor");
+  }
+}
+CronDate.prototype.fromDate = function(inDate) {
+  if (this.tz !== void 0) {
+    if (typeof this.tz === "number") {
+      this.ms = inDate.getUTCMilliseconds();
+      this.second = inDate.getUTCSeconds();
+      this.minute = inDate.getUTCMinutes() + this.tz;
+      this.hour = inDate.getUTCHours();
+      this.day = inDate.getUTCDate();
+      this.month = inDate.getUTCMonth();
+      this.year = inDate.getUTCFullYear();
+      this.apply();
+    } else {
+      const d = minitz.toTZ(inDate, this.tz);
+      this.ms = inDate.getMilliseconds();
+      this.second = d.s;
+      this.minute = d.i;
+      this.hour = d.h;
+      this.day = d.d;
+      this.month = d.m - 1;
+      this.year = d.y;
+    }
+  } else {
+    this.ms = inDate.getMilliseconds();
+    this.second = inDate.getSeconds();
+    this.minute = inDate.getMinutes();
+    this.hour = inDate.getHours();
+    this.day = inDate.getDate();
+    this.month = inDate.getMonth();
+    this.year = inDate.getFullYear();
+  }
+};
+CronDate.prototype.fromCronDate = function(d) {
+  this.tz = d.tz;
+  this.year = d.year;
+  this.month = d.month;
+  this.day = d.day;
+  this.hour = d.hour;
+  this.minute = d.minute;
+  this.second = d.second;
+  this.ms = d.ms;
+};
+CronDate.prototype.apply = function() {
+  if (this.month > 11 || this.day > DaysOfMonth[this.month] || this.hour > 59 || this.minute > 59 || this.second > 59 || this.hour < 0 || this.minute < 0 || this.second < 0) {
+    const d = new Date(Date.UTC(this.year, this.month, this.day, this.hour, this.minute, this.second, this.ms));
+    this.ms = d.getUTCMilliseconds();
+    this.second = d.getUTCSeconds();
+    this.minute = d.getUTCMinutes();
+    this.hour = d.getUTCHours();
+    this.day = d.getUTCDate();
+    this.month = d.getUTCMonth();
+    this.year = d.getUTCFullYear();
+    return true;
+  } else {
+    return false;
+  }
+};
+CronDate.prototype.fromString = function(str) {
+  return this.fromDate(minitz.fromTZISO(str, this.tz));
+};
+CronDate.prototype.findNext = function(options, target, pattern, offset) {
+  const originalTarget = this[target];
+  let lastDayOfMonth;
+  if (pattern.lastDayOfMonth) {
+    if (this.month !== 1) {
+      lastDayOfMonth = DaysOfMonth[this.month];
+    } else {
+      lastDayOfMonth = new Date(Date.UTC(this.year, this.month + 1, 0, 0, 0, 0, 0)).getUTCDate();
+    }
+  }
+  const fDomWeekDay = !pattern.starDOW && target == "day" ? new Date(Date.UTC(this.year, this.month, 1, 0, 0, 0, 0)).getUTCDay() : void 0;
+  for (let i = this[target] + offset; i < pattern[target].length; i++) {
+    let match = pattern[target][i];
+    if (target === "day" && pattern.lastDayOfMonth && i - offset == lastDayOfMonth) {
+      match = true;
+    }
+    if (target === "day" && !pattern.starDOW) {
+      const dowMatch = pattern.dow[(fDomWeekDay + (i - offset - 1)) % 7];
+      if (options.legacyMode && !pattern.starDOM) {
+        match = match || dowMatch;
+      } else {
+        match = match && dowMatch;
+      }
+    }
+    if (match) {
+      this[target] = i - offset;
+      return originalTarget !== this[target] ? 2 : 1;
+    }
+  }
+  return 3;
+};
+CronDate.prototype.recurse = function(pattern, options, doing) {
+  const res = this.findNext(options, RecursionSteps[doing][0], pattern, RecursionSteps[doing][2]);
+  if (res > 1) {
+    let resetLevel = doing + 1;
+    while (resetLevel < RecursionSteps.length) {
+      this[RecursionSteps[resetLevel][0]] = -RecursionSteps[resetLevel][2];
+      resetLevel++;
+    }
+    if (res === 3) {
+      this[RecursionSteps[doing][1]]++;
+      this[RecursionSteps[doing][0]] = -RecursionSteps[doing][2];
+      this.apply();
+      return this.recurse(pattern, options, 0);
+    } else if (this.apply()) {
+      return this.recurse(pattern, options, doing - 1);
+    }
+  }
+  doing += 1;
+  if (doing >= RecursionSteps.length) {
+    return this;
+  } else if (this.year >= 3e3) {
+    return null;
+  } else {
+    return this.recurse(pattern, options, doing);
+  }
+};
+CronDate.prototype.increment = function(pattern, options, hasPreviousRun) {
+  if (options.interval > 1 && hasPreviousRun) {
+    this.second += options.interval;
+  } else {
+    this.second += 1;
+  }
+  this.ms = 0;
+  this.apply();
+  return this.recurse(pattern, options, 0);
+};
+CronDate.prototype.getDate = function(internal) {
+  if (internal || this.tz === void 0 && this.utcOffset === void 0) {
+    return new Date(this.year, this.month, this.day, this.hour, this.minute, this.second, this.ms);
+  } else {
+    if (typeof this.tz === "number") {
+      return new Date(Date.UTC(this.year, this.month, this.day, this.hour, this.minute - this.tz, this.second, this.ms));
+    } else {
+      return minitz(this.year, this.month + 1, this.day, this.hour, this.minute, this.second, this.tz);
+    }
+  }
+};
+CronDate.prototype.getTime = function() {
+  return this.getDate().getTime();
+};
+function CronPattern(pattern, timezone) {
+  this.pattern = pattern;
+  this.timezone = timezone;
+  this.second = Array(60).fill(0);
+  this.minute = Array(60).fill(0);
+  this.hour = Array(24).fill(0);
+  this.day = Array(31).fill(0);
+  this.month = Array(12).fill(0);
+  this.dow = Array(8).fill(0);
+  this.lastDayOfMonth = false;
+  this.starDOM = false;
+  this.starDOW = false;
+  this.parse();
+}
+CronPattern.prototype.parse = function() {
+  if (!(typeof this.pattern === "string" || this.pattern.constructor === String)) {
+    throw new TypeError("CronPattern: Pattern has to be of type string.");
+  }
+  if (this.pattern.indexOf("@") >= 0)
+    this.pattern = this.handleNicknames(this.pattern).trim();
+  const parts = this.pattern.replace(/\s+/g, " ").split(" ");
+  if (parts.length < 5 || parts.length > 6) {
+    throw new TypeError("CronPattern: invalid configuration format ('" + this.pattern + "'), exacly five or six space separated parts required.");
+  }
+  if (parts.length === 5) {
+    parts.unshift("0");
+  }
+  if (parts[3].indexOf("L") >= 0) {
+    parts[3] = parts[3].replace("L", "");
+    this.lastDayOfMonth = true;
+  }
+  if (parts[3] == "*") {
+    this.starDOM = true;
+  }
+  if (parts[4].length >= 3)
+    parts[4] = this.replaceAlphaMonths(parts[4]);
+  if (parts[5].length >= 3)
+    parts[5] = this.replaceAlphaDays(parts[5]);
+  if (parts[5] == "*") {
+    this.starDOW = true;
+  }
+  if (this.pattern.indexOf("?") >= 0) {
+    const initDate = new CronDate(/* @__PURE__ */ new Date(), this.timezone).getDate(true);
+    parts[0] = parts[0].replace("?", initDate.getSeconds());
+    parts[1] = parts[1].replace("?", initDate.getMinutes());
+    parts[2] = parts[2].replace("?", initDate.getHours());
+    if (!this.starDOM)
+      parts[3] = parts[3].replace("?", initDate.getDate());
+    parts[4] = parts[4].replace("?", initDate.getMonth() + 1);
+    if (!this.starDOW)
+      parts[5] = parts[5].replace("?", initDate.getDay());
+  }
+  this.throwAtIllegalCharacters(parts);
+  this.partToArray("second", parts[0], 0);
+  this.partToArray("minute", parts[1], 0);
+  this.partToArray("hour", parts[2], 0);
+  this.partToArray("day", parts[3], -1);
+  this.partToArray("month", parts[4], -1);
+  this.partToArray("dow", parts[5], 0);
+  if (this.dow[7]) {
+    this.dow[0] = 1;
+  }
+};
+CronPattern.prototype.partToArray = function(type, conf, valueIndexOffset) {
+  const arr = this[type];
+  if (conf === "*")
+    return arr.fill(1);
+  const split = conf.split(",");
+  if (split.length > 1) {
+    for (let i = 0; i < split.length; i++) {
+      this.partToArray(type, split[i], valueIndexOffset);
+    }
+  } else if (conf.indexOf("-") !== -1 && conf.indexOf("/") !== -1) {
+    this.handleRangeWithStepping(conf, type, valueIndexOffset);
+  } else if (conf.indexOf("-") !== -1) {
+    this.handleRange(conf, type, valueIndexOffset);
+  } else if (conf.indexOf("/") !== -1) {
+    this.handleStepping(conf, type, valueIndexOffset);
+  } else if (conf !== "") {
+    this.handleNumber(conf, type, valueIndexOffset);
+  }
+};
+CronPattern.prototype.throwAtIllegalCharacters = function(parts) {
+  const reValidCron = /[^/*0-9,-]+/;
+  for (let i = 0; i < parts.length; i++) {
+    if (reValidCron.test(parts[i])) {
+      throw new TypeError("CronPattern: configuration entry " + i + " (" + parts[i] + ") contains illegal characters.");
+    }
+  }
+};
+CronPattern.prototype.handleNumber = function(conf, type, valueIndexOffset) {
+  const i = parseInt(conf, 10) + valueIndexOffset;
+  if (isNaN(i)) {
+    throw new TypeError("CronPattern: " + type + " is not a number: '" + conf + "'");
+  }
+  if (i < 0 || i >= this[type].length) {
+    throw new TypeError("CronPattern: " + type + " value out of range: '" + conf + "'");
+  }
+  this[type][i] = 1;
+};
+CronPattern.prototype.handleRangeWithStepping = function(conf, type, valueIndexOffset) {
+  const matches = conf.match(/^(\d+)-(\d+)\/(\d+)$/);
+  if (matches === null)
+    throw new TypeError("CronPattern: Syntax error, illegal range with stepping: '" + conf + "'");
+  let [, lower, upper, steps] = matches;
+  lower = parseInt(lower, 10) + valueIndexOffset;
+  upper = parseInt(upper, 10) + valueIndexOffset;
+  steps = parseInt(steps, 10);
+  if (isNaN(lower))
+    throw new TypeError("CronPattern: Syntax error, illegal lower range (NaN)");
+  if (isNaN(upper))
+    throw new TypeError("CronPattern: Syntax error, illegal upper range (NaN)");
+  if (isNaN(steps))
+    throw new TypeError("CronPattern: Syntax error, illegal stepping: (NaN)");
+  if (steps === 0)
+    throw new TypeError("CronPattern: Syntax error, illegal stepping: 0");
+  if (steps > this[type].length)
+    throw new TypeError("CronPattern: Syntax error, steps cannot be greater than maximum value of part (" + this[type].length + ")");
+  if (lower < 0 || upper >= this[type].length)
+    throw new TypeError("CronPattern: Value out of range: '" + conf + "'");
+  if (lower > upper)
+    throw new TypeError("CronPattern: From value is larger than to value: '" + conf + "'");
+  for (let i = lower; i <= upper; i += steps) {
+    this[type][i] = 1;
+  }
+};
+CronPattern.prototype.handleRange = function(conf, type, valueIndexOffset) {
+  const split = conf.split("-");
+  if (split.length !== 2) {
+    throw new TypeError("CronPattern: Syntax error, illegal range: '" + conf + "'");
+  }
+  const lower = parseInt(split[0], 10) + valueIndexOffset, upper = parseInt(split[1], 10) + valueIndexOffset;
+  if (isNaN(lower)) {
+    throw new TypeError("CronPattern: Syntax error, illegal lower range (NaN)");
+  } else if (isNaN(upper)) {
+    throw new TypeError("CronPattern: Syntax error, illegal upper range (NaN)");
+  }
+  if (lower < 0 || upper >= this[type].length) {
+    throw new TypeError("CronPattern: Value out of range: '" + conf + "'");
+  }
+  if (lower > upper) {
+    throw new TypeError("CronPattern: From value is larger than to value: '" + conf + "'");
+  }
+  for (let i = lower; i <= upper; i++) {
+    this[type][i] = 1;
+  }
+};
+CronPattern.prototype.handleStepping = function(conf, type) {
+  const split = conf.split("/");
+  if (split.length !== 2) {
+    throw new TypeError("CronPattern: Syntax error, illegal stepping: '" + conf + "'");
+  }
+  let start = 0;
+  if (split[0] !== "*") {
+    start = parseInt(split[0], 10);
+  }
+  const steps = parseInt(split[1], 10);
+  if (isNaN(steps))
+    throw new TypeError("CronPattern: Syntax error, illegal stepping: (NaN)");
+  if (steps === 0)
+    throw new TypeError("CronPattern: Syntax error, illegal stepping: 0");
+  if (steps > this[type].length)
+    throw new TypeError("CronPattern: Syntax error, max steps for part is (" + this[type].length + ")");
+  for (let i = start; i < this[type].length; i += steps) {
+    this[type][i] = 1;
+  }
+};
+CronPattern.prototype.replaceAlphaDays = function(conf) {
+  return conf.replace(/-sun/gi, "-7").replace(/sun/gi, "0").replace(/mon/gi, "1").replace(/tue/gi, "2").replace(/wed/gi, "3").replace(/thu/gi, "4").replace(/fri/gi, "5").replace(/sat/gi, "6");
+};
+CronPattern.prototype.replaceAlphaMonths = function(conf) {
+  return conf.replace(/jan/gi, "1").replace(/feb/gi, "2").replace(/mar/gi, "3").replace(/apr/gi, "4").replace(/may/gi, "5").replace(/jun/gi, "6").replace(/jul/gi, "7").replace(/aug/gi, "8").replace(/sep/gi, "9").replace(/oct/gi, "10").replace(/nov/gi, "11").replace(/dec/gi, "12");
+};
+CronPattern.prototype.handleNicknames = function(pattern) {
+  const cleanPattern = pattern.trim().toLowerCase();
+  if (cleanPattern === "@yearly" || cleanPattern === "@annually") {
+    return "0 0 1 1 *";
+  } else if (cleanPattern === "@monthly") {
+    return "0 0 1 * *";
+  } else if (cleanPattern === "@weekly") {
+    return "0 0 * * 0";
+  } else if (cleanPattern === "@daily") {
+    return "0 0 * * *";
+  } else if (cleanPattern === "@hourly") {
+    return "0 * * * *";
+  } else {
+    return pattern;
+  }
+};
+var maxDelay = Math.pow(2, 32 - 1) - 1;
+var scheduledJobs = [];
+function isFn(v) {
+  return Object.prototype.toString.call(v) === "[object Function]" || "function" === typeof v || v instanceof Function;
+}
+function unref(timer2) {
+  if (typeof Deno !== "undefined" && typeof Deno.unrefTimer !== "undefined") {
+    Deno.unrefTimer(timer2);
+  } else if (timer2 && typeof timer2.unref !== "undefined") {
+    timer2.unref();
+  }
+}
+function Cron(pattern, fnOrOptions1, fnOrOptions2) {
+  if (!(this instanceof Cron)) {
+    return new Cron(pattern, fnOrOptions1, fnOrOptions2);
+  }
+  let options, func;
+  if (typeof fnOrOptions1 === "function") {
+    func = fnOrOptions1;
+  } else if (typeof fnOrOptions1 === "object") {
+    options = fnOrOptions1;
+  } else if (fnOrOptions1 !== void 0) {
+    throw new Error("Cron: Invalid argument passed for optionsIn. Should be one of function, or object (options).");
+  }
+  if (typeof fnOrOptions2 === "function") {
+    func = fnOrOptions2;
+  } else if (typeof fnOrOptions2 === "object") {
+    options = fnOrOptions2;
+  } else if (fnOrOptions2 !== void 0) {
+    throw new Error("Cron: Invalid argument passed for funcIn. Should be one of function, or object (options).");
+  }
+  this.name = options ? options.name : void 0;
+  this.options = CronOptions(options);
+  this.once = void 0;
+  this.pattern = void 0;
+  this.blocking = false;
+  this.previousrun = void 0;
+  this.runstarted = void 0;
+  if (pattern && (pattern instanceof Date || typeof pattern === "string" && pattern.indexOf(":") > 0)) {
+    this.once = new CronDate(pattern, this.options.timezone || this.options.utcOffset);
+  } else {
+    this.pattern = new CronPattern(pattern, this.options.timezone);
+  }
+  if (func !== void 0) {
+    this.fn = func;
+    this.schedule();
+  }
+  if (this.name) {
+    const existing = scheduledJobs.find((j) => j.name === this.name);
+    if (existing) {
+      throw new Error("Cron: Tried to initialize new named job '" + this.name + "', but name already taken.");
+    } else {
+      scheduledJobs.push(this);
+    }
+  }
+  return this;
+}
+Cron.prototype.next = function(prev) {
+  const next = this._next(prev);
+  return next ? next.getDate() : null;
+};
+Cron.prototype.enumerate = function(n, previous) {
+  if (n > this.options.maxRuns) {
+    n = this.options.maxRuns;
+  }
+  const enumeration = [];
+  let prev = previous || this.previousrun;
+  while (n-- && (prev = this.next(prev))) {
+    enumeration.push(prev);
+  }
+  return enumeration;
+};
+Cron.prototype.running = function() {
+  const msLeft = this.msToNext(this.previousrun);
+  const running = !this.options.paused && this.fn !== void 0;
+  return msLeft !== null && running;
+};
+Cron.prototype.busy = function() {
+  return this.blocking;
+};
+Cron.prototype.started = function() {
+  return this.runstarted ? this.runstarted.getDate() : null;
+};
+Cron.prototype.previous = function() {
+  return this.previousrun ? this.previousrun.getDate() : null;
+};
+Cron.prototype.msToNext = function(prev) {
+  const next = this._next(prev);
+  prev = new CronDate(prev, this.options.timezone || this.options.utcOffset);
+  if (next) {
+    return next.getTime(true) - prev.getTime(true);
+  } else {
+    return null;
+  }
+};
+Cron.prototype.stop = function() {
+  this.options.kill = true;
+  if (this.currentTimeout) {
+    clearTimeout(this.currentTimeout);
+  }
+};
+Cron.prototype.pause = function() {
+  return (this.options.paused = true) && !this.options.kill;
+};
+Cron.prototype.resume = function() {
+  return !(this.options.paused = false) && !this.options.kill;
+};
+Cron.prototype.schedule = function(func, partial) {
+  if (func && this.fn) {
+    throw new Error("Cron: It is not allowed to schedule two functions using the same Croner instance.");
+  } else if (func) {
+    this.fn = func;
+  }
+  let waitMs = this.msToNext(partial ? partial : this.previousrun);
+  const target = this.next(partial ? partial : this.previousrun);
+  if (waitMs === null || target === null)
+    return this;
+  if (waitMs > maxDelay) {
+    waitMs = maxDelay;
+  }
+  this.currentTimeout = setTimeout(() => this._checkTrigger(target), waitMs);
+  if (this.currentTimeout && this.options.unref) {
+    unref(this.currentTimeout);
+  }
+  return this;
+};
+Cron.prototype._trigger = async function(initiationDate) {
+  this.blocking = true;
+  this.runstarted = new CronDate(initiationDate, this.options.timezone || this.options.utcOffset);
+  if (this.options.catch) {
+    try {
+      await this.fn(this, this.options.context);
+    } catch (_e) {
+      if (isFn(this.options.catch)) {
+        ((inst) => inst.options.catch(_e, inst))(this);
+      }
+    } finally {
+      this.blocking = false;
+    }
+  } else {
+    await this.fn(this, this.options.context);
+    this.blocking = false;
+  }
+};
+Cron.prototype._checkTrigger = function(target) {
+  const now = /* @__PURE__ */ new Date(), shouldRun = !this.options.paused && now.getTime() >= target, isBlocked = this.blocking && this.options.protect;
+  if (shouldRun && !isBlocked) {
+    this.options.maxRuns--;
+    this._trigger();
+    this.previousrun = new CronDate(void 0, this.options.timezone || this.options.utcOffset);
+    this.schedule();
+  } else {
+    if (shouldRun && isBlocked && isFn(this.options.protect)) {
+      (async (inst) => inst.options.protect(inst))(this);
+    }
+    this.schedule(void 0, now);
+  }
+};
+Cron.prototype._next = function(prev) {
+  const hasPreviousRun = prev || this.previousrun ? true : false;
+  prev = new CronDate(prev, this.options.timezone || this.options.utcOffset);
+  if (this.options.startAt && prev && prev.getTime() < this.options.startAt.getTime()) {
+    prev = this.options.startAt;
+  }
+  const nextRun = this.once || new CronDate(prev, this.options.timezone || this.options.utcOffset).increment(this.pattern, this.options, hasPreviousRun);
+  if (this.once && this.once.getTime() <= prev.getTime()) {
+    return null;
+  } else if (nextRun === null || this.options.maxRuns <= 0 || this.options.kill || this.options.stopAt && nextRun.getTime() >= this.options.stopAt.getTime()) {
+    return null;
+  } else {
+    return nextRun;
+  }
+};
+Cron.Cron = Cron;
+Cron.scheduledJobs = scheduledJobs;
+
+// node_modules/.pnpm/@push.rocks+smarttime@4.0.5/node_modules/@push.rocks/smarttime/dist_ts/smarttime.plugins.js
+var import_dayjs = __toESM(require_dayjs_min(), 1);
+var import_isToday = __toESM(require_isToday(), 1);
+import_dayjs.default.extend(import_isToday.default);
+
+// node_modules/.pnpm/@push.rocks+lik@6.0.5/node_modules/@push.rocks/lik/dist_ts/lik.plugins.js
+var import_symbol_tree = __toESM(require_SymbolTree(), 1);
+
+// node_modules/.pnpm/idb@7.1.1/node_modules/idb/build/index.js
+var build_exports = {};
+__export(build_exports, {
+  deleteDB: () => deleteDB,
+  openDB: () => openDB,
+  unwrap: () => unwrap,
+  wrap: () => wrap
+});
+
+// node_modules/.pnpm/idb@7.1.1/node_modules/idb/build/wrap-idb-value.js
+var instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+var idbProxyableTypes;
+var cursorAdvanceMethods;
+function getIdbProxyableTypes() {
+  return idbProxyableTypes || (idbProxyableTypes = [
+    IDBDatabase,
+    IDBObjectStore,
+    IDBIndex,
+    IDBCursor,
+    IDBTransaction
+  ]);
+}
+function getCursorAdvanceMethods() {
+  return cursorAdvanceMethods || (cursorAdvanceMethods = [
+    IDBCursor.prototype.advance,
+    IDBCursor.prototype.continue,
+    IDBCursor.prototype.continuePrimaryKey
+  ]);
+}
+var cursorRequestMap = /* @__PURE__ */ new WeakMap();
+var transactionDoneMap = /* @__PURE__ */ new WeakMap();
+var transactionStoreNamesMap = /* @__PURE__ */ new WeakMap();
+var transformCache = /* @__PURE__ */ new WeakMap();
+var reverseTransformCache = /* @__PURE__ */ new WeakMap();
+function promisifyRequest(request) {
+  const promise = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      request.removeEventListener("success", success);
+      request.removeEventListener("error", error);
+    };
+    const success = () => {
+      resolve(wrap(request.result));
+      unlisten();
+    };
+    const error = () => {
+      reject(request.error);
+      unlisten();
+    };
+    request.addEventListener("success", success);
+    request.addEventListener("error", error);
+  });
+  promise.then((value) => {
+    if (value instanceof IDBCursor) {
+      cursorRequestMap.set(value, request);
+    }
+  }).catch(() => {
+  });
+  reverseTransformCache.set(promise, request);
+  return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+  if (transactionDoneMap.has(tx))
+    return;
+  const done = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      tx.removeEventListener("complete", complete);
+      tx.removeEventListener("error", error);
+      tx.removeEventListener("abort", error);
+    };
+    const complete = () => {
+      resolve();
+      unlisten();
+    };
+    const error = () => {
+      reject(tx.error || new DOMException("AbortError", "AbortError"));
+      unlisten();
+    };
+    tx.addEventListener("complete", complete);
+    tx.addEventListener("error", error);
+    tx.addEventListener("abort", error);
+  });
+  transactionDoneMap.set(tx, done);
+}
+var idbProxyTraps = {
+  get(target, prop, receiver) {
+    if (target instanceof IDBTransaction) {
+      if (prop === "done")
+        return transactionDoneMap.get(target);
+      if (prop === "objectStoreNames") {
+        return target.objectStoreNames || transactionStoreNamesMap.get(target);
+      }
+      if (prop === "store") {
+        return receiver.objectStoreNames[1] ? void 0 : receiver.objectStore(receiver.objectStoreNames[0]);
+      }
+    }
+    return wrap(target[prop]);
+  },
+  set(target, prop, value) {
+    target[prop] = value;
+    return true;
+  },
+  has(target, prop) {
+    if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) {
+      return true;
+    }
+    return prop in target;
+  }
+};
+function replaceTraps(callback) {
+  idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+  if (func === IDBDatabase.prototype.transaction && !("objectStoreNames" in IDBTransaction.prototype)) {
+    return function(storeNames, ...args) {
+      const tx = func.call(unwrap(this), storeNames, ...args);
+      transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
+      return wrap(tx);
+    };
+  }
+  if (getCursorAdvanceMethods().includes(func)) {
+    return function(...args) {
+      func.apply(unwrap(this), args);
+      return wrap(cursorRequestMap.get(this));
+    };
+  }
+  return function(...args) {
+    return wrap(func.apply(unwrap(this), args));
+  };
+}
+function transformCachableValue(value) {
+  if (typeof value === "function")
+    return wrapFunction(value);
+  if (value instanceof IDBTransaction)
+    cacheDonePromiseForTransaction(value);
+  if (instanceOfAny(value, getIdbProxyableTypes()))
+    return new Proxy(value, idbProxyTraps);
+  return value;
+}
+function wrap(value) {
+  if (value instanceof IDBRequest)
+    return promisifyRequest(value);
+  if (transformCache.has(value))
+    return transformCache.get(value);
+  const newValue = transformCachableValue(value);
+  if (newValue !== value) {
+    transformCache.set(value, newValue);
+    reverseTransformCache.set(newValue, value);
+  }
+  return newValue;
+}
+var unwrap = (value) => reverseTransformCache.get(value);
+
+// node_modules/.pnpm/idb@7.1.1/node_modules/idb/build/index.js
+function openDB(name, version2, { blocked, upgrade, blocking, terminated } = {}) {
+  const request = indexedDB.open(name, version2);
+  const openPromise = wrap(request);
+  if (upgrade) {
+    request.addEventListener("upgradeneeded", (event) => {
+      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+    });
+  }
+  if (blocked) {
+    request.addEventListener("blocked", (event) => blocked(
+      // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+      event.oldVersion,
+      event.newVersion,
+      event
+    ));
+  }
+  openPromise.then((db) => {
+    if (terminated)
+      db.addEventListener("close", () => terminated());
+    if (blocking) {
+      db.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
+    }
+  }).catch(() => {
+  });
+  return openPromise;
+}
+function deleteDB(name, { blocked } = {}) {
+  const request = indexedDB.deleteDatabase(name);
+  if (blocked) {
+    request.addEventListener("blocked", (event) => blocked(
+      // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+      event.oldVersion,
+      event
+    ));
+  }
+  return wrap(request).then(() => void 0);
+}
+var readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
+var writeMethods = ["put", "add", "delete", "clear"];
+var cachedMethods = /* @__PURE__ */ new Map();
+function getMethod(target, prop) {
+  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) {
+    return;
+  }
+  if (cachedMethods.get(prop))
+    return cachedMethods.get(prop);
+  const targetFuncName = prop.replace(/FromIndex$/, "");
+  const useIndex = prop !== targetFuncName;
+  const isWrite = writeMethods.includes(targetFuncName);
+  if (
+    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))
+  ) {
+    return;
+  }
+  const method = async function(storeName, ...args) {
+    const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
+    let target2 = tx.store;
+    if (useIndex)
+      target2 = target2.index(args.shift());
+    return (await Promise.all([
+      target2[targetFuncName](...args),
+      isWrite && tx.done
+    ]))[0];
+  };
+  cachedMethods.set(prop, method);
+  return method;
+}
+replaceTraps((oldTraps) => ({
+  ...oldTraps,
+  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+}));
+
+// node_modules/.pnpm/@push.rocks+webstore@2.0.13/node_modules/@push.rocks/webstore/dist_ts/webstore.classes.webstore.js
+var WebStore = class {
+  constructor(optionsArg) {
+    this.initCalled = false;
+    this.readyDeferred = dist_ts_exports6.defer();
+    this.options = optionsArg;
+  }
+  async init() {
+    if (this.initCalled) {
+      await this.readyDeferred.promise;
+      return;
+    }
+    this.initCalled = true;
+    const smartenv = new dist_ts_exports3.Smartenv();
+    if (!smartenv.isBrowser && !globalThis.indexedDB) {
+      console.log("hey");
+      console.log(globalThis.indexedDB);
+      await smartenv.getSafeNodeModule("fake-indexeddb/auto");
+      if (!globalThis.indexedDB) {
+        const mod = await smartenv.getSafeNodeModule("fake-indexeddb");
+        globalThis.indexedDB = new mod.IDBFactory();
+      }
+    }
+    this.db = await build_exports.openDB(this.options.dbName, 1, {
+      upgrade: (db) => {
+        db.createObjectStore(this.options.storeName);
+      }
+    });
+    this.readyDeferred.resolve();
+    return;
+  }
+  async get(key) {
+    await this.init();
+    return this.db.get(this.options.storeName, key);
+  }
+  async check(keyArg) {
+    await this.init();
+    const result = await this.get(keyArg);
+    return !!result;
+  }
+  async set(key, val) {
+    await this.init();
+    return this.db.put(this.options.storeName, val, key);
+  }
+  async delete(key) {
+    await this.init();
+    return this.db.delete(this.options.storeName, key);
+  }
+  async clear() {
+    await this.init();
+    return this.db.clear(this.options.storeName);
+  }
+  async keys() {
+    await this.init();
+    return this.db.getAllKeys(this.options.storeName);
+  }
+};
+
+// node_modules/.pnpm/@push.rocks+webstore@2.0.13/node_modules/@push.rocks/webstore/dist_ts/webstore.classes.typedrequestcache.js
+var TypedrequestCache = class {
+  constructor(domainArg = "default") {
+    this.webstore = new WebStore({
+      dbName: "trStore",
+      storeName: `trStore-${domainArg}`
+    });
+  }
+  buildKey(requestArg) {
+    return dist_ts_exports5.stringify({
+      method: requestArg.method,
+      request: requestArg.request
+    });
+  }
+  /**
+   * stores by request
+   * @param typedrequestarg
+   */
+  async setByRequest(typedrequestArg) {
+    if (!typedrequestArg.response) {
+      throw new Error("You cannot store requests without a response present");
+    }
+    await this.webstore.set(this.buildKey(typedrequestArg), typedrequestArg);
+  }
+  /**
+   * get by full tyoedrequest by partial typedrequest
+   * @param typedrequestarg
+   */
+  async getByRequest(typedrequestArg) {
+    const result = await this.webstore.get(this.buildKey(typedrequestArg));
+    return result;
+  }
+};
+
 // ts/smartstate.classes.stateaction.ts
 var StateAction = class {
   constructor(statePartRef, actionDef) {
@@ -8973,10 +11061,29 @@ var StateAction = class {
 
 // ts/smartstate.classes.statepart.ts
 var StatePart2 = class {
-  constructor(nameArg) {
+  // Add WebStore instance
+  constructor(nameArg, webStoreOptions) {
     this.state = new dist_ts_exports7.rxjs.Subject();
     this.cumulativeDeferred = dist_ts_exports6.cumulativeDefer();
+    this.webStore = null;
     this.name = nameArg;
+    if (webStoreOptions) {
+      this.webStore = new dist_ts_exports13.WebStore(webStoreOptions);
+      this.initWebStore();
+    }
+  }
+  /**
+   * initializes the webstore
+   */
+  async initWebStore() {
+    if (this.webStore) {
+      await this.webStore.init();
+      const storedState = await this.webStore.get(String(this.name));
+      if (storedState) {
+        this.stateStore = storedState;
+        this.notifyChange();
+      }
+    }
   }
   /**
    * gets the state from the state store
@@ -8988,9 +11095,12 @@ var StatePart2 = class {
    * sets the stateStore to the new state
    * @param newStateArg
    */
-  setState(newStateArg) {
+  async setState(newStateArg) {
     this.stateStore = newStateArg;
     this.notifyChange();
+    if (this.webStore) {
+      await this.webStore.set(String(this.name), newStateArg);
+    }
   }
   /**
    * notifies of a change on the state