autoql-fe-utils 1.0.0

package/dist/index.global.js

@@ -0,0 +1,3039 @@
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw new Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // node_modules/dayjs/dayjs.min.js
+  var require_dayjs_min = __commonJS({
+    "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", f = "month", h = "quarter", c = "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, f), s2 = n2 - i2 < 0, u2 = e2.clone().add(r2 + (s2 ? -1 : 1), f);
+          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: f, y: c, w: o, d: a, D: d, h: u, m: s, s: i, ms: r, Q: h }[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 _;
+        }, 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 _(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 _ = 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, h2 = 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 (h2) {
+              case c:
+                return r2 ? l2(1, 0) : l2(31, 11);
+              case f:
+                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), h2 = "set" + (this.$u ? "UTC" : ""), l2 = (n2 = {}, n2[a] = h2 + "Date", n2[d] = h2 + "Date", n2[f] = h2 + "Month", n2[c] = h2 + "FullYear", n2[u] = h2 + "Hours", n2[s] = h2 + "Minutes", n2[i] = h2 + "Seconds", n2[r] = h2 + "Milliseconds", n2)[o2], $2 = o2 === a ? this.$D + (e2 - this.$W) : e2;
+            if (o2 === f || o2 === c) {
+              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, h2) {
+            var d2, l2 = this;
+            r2 = Number(r2);
+            var $2 = O.p(h2), y2 = function(t2) {
+              var e2 = w(l2);
+              return O.w(e2.date(e2.date() + Math.round(t2 * r2)), l2);
+            };
+            if ($2 === f)
+              return this.set(f, this.$M + r2);
+            if ($2 === c)
+              return this.set(c, 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, f2 = n2.months, h2 = function(t3, n3, i3, s3) {
+              return t3 && (t3[n3] || t3(e2, r2)) || i3[n3].slice(0, s3);
+            }, c2 = function(t3) {
+              return O.s(s2 % 12 || 12, t3, "0");
+            }, d2 = n2.meridiem || function(t3, e3, n3) {
+              var r3 = t3 < 12 ? "AM" : "PM";
+              return n3 ? r3.toLowerCase() : r3;
+            }, $2 = { YY: String(this.$y).slice(-2), YYYY: O.s(this.$y, 4, "0"), M: a2 + 1, MM: O.s(a2 + 1, 2, "0"), MMM: h2(n2.monthsShort, a2, f2, 3), MMMM: h2(f2, a2), D: this.$D, DD: O.s(this.$D, 2, "0"), d: String(this.$W), dd: h2(n2.weekdaysMin, this.$W, o2, 2), ddd: h2(n2.weekdaysShort, this.$W, o2, 3), dddd: o2[this.$W], H: String(s2), HH: O.s(s2, 2, "0"), h: c2(1), hh: c2(2), a: d2(s2, u2, true), A: d2(s2, u2, false), m: String(u2), mm: O.s(u2, 2, "0"), s: String(this.$s), ss: O.s(this.$s, 2, "0"), SSS: O.s(this.$ms, 3, "0"), Z: i2 };
+            return r2.replace(y, function(t3, e3) {
+              return e3 || $2[t3] || i2.replace(":", "");
+            });
+          }, m2.utcOffset = function() {
+            return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+          }, m2.diff = function(r2, d2, l2) {
+            var $2, y2 = O.p(d2), M3 = w(r2), m3 = (M3.utcOffset() - this.utcOffset()) * e, v2 = this - M3, g2 = O.m(this, M3);
+            return g2 = ($2 = {}, $2[c] = g2 / 12, $2[f] = g2, $2[h] = g2 / 3, $2[o] = (v2 - m3) / 6048e5, $2[a] = (v2 - m3) / 864e5, $2[u] = v2 / n, $2[s] = v2 / e, $2[i] = v2 / t, $2)[y2] || v2, l2 ? g2 : O.a(g2);
+          }, m2.daysInMonth = function() {
+            return this.endOf(f).$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;
+        }(), T = _.prototype;
+        return w.prototype = T, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", f], ["$y", c], ["$D", d]].forEach(function(t2) {
+          T[t2[1]] = function(e2) {
+            return this.$g(e2, t2[0], t2[1]);
+          };
+        }), w.extend = function(t2, e2) {
+          return t2.$i || (t2(e2, _, 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/dayjs/plugin/advancedFormat.js
+  var require_advancedFormat = __commonJS({
+    "node_modules/dayjs/plugin/advancedFormat.js"(exports, module) {
+      !function(e, t) {
+        "object" == typeof exports && "undefined" != typeof module ? module.exports = t() : "function" == typeof define && define.amd ? define(t) : (e = "undefined" != typeof globalThis ? globalThis : e || self).dayjs_plugin_advancedFormat = t();
+      }(exports, function() {
+        "use strict";
+        return function(e, t) {
+          var r = t.prototype, n = r.format;
+          r.format = function(e2) {
+            var t2 = this, r2 = this.$locale();
+            if (!this.isValid())
+              return n.bind(this)(e2);
+            var s = this.$utils(), a = (e2 || "YYYY-MM-DDTHH:mm:ssZ").replace(/\[([^\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g, function(e3) {
+              switch (e3) {
+                case "Q":
+                  return Math.ceil((t2.$M + 1) / 3);
+                case "Do":
+                  return r2.ordinal(t2.$D);
+                case "gggg":
+                  return t2.weekYear();
+                case "GGGG":
+                  return t2.isoWeekYear();
+                case "wo":
+                  return r2.ordinal(t2.week(), "W");
+                case "w":
+                case "ww":
+                  return s.s(t2.week(), "w" === e3 ? 1 : 2, "0");
+                case "W":
+                case "WW":
+                  return s.s(t2.isoWeek(), "W" === e3 ? 1 : 2, "0");
+                case "k":
+                case "kk":
+                  return s.s(String(0 === t2.$H ? 24 : t2.$H), "k" === e3 ? 1 : 2, "0");
+                case "X":
+                  return Math.floor(t2.$d.getTime() / 1e3);
+                case "x":
+                  return t2.$d.getTime();
+                case "z":
+                  return "[" + t2.offsetName() + "]";
+                case "zzz":
+                  return "[" + t2.offsetName("long") + "]";
+                default:
+                  return e3;
+              }
+            });
+            return n.bind(this)(a);
+          };
+        };
+      });
+    }
+  });
+
+  // node_modules/dayjs/plugin/localizedFormat.js
+  var require_localizedFormat = __commonJS({
+    "node_modules/dayjs/plugin/localizedFormat.js"(exports, module) {
+      !function(e, t) {
+        "object" == typeof exports && "undefined" != typeof module ? module.exports = t() : "function" == typeof define && define.amd ? define(t) : (e = "undefined" != typeof globalThis ? globalThis : e || self).dayjs_plugin_localizedFormat = t();
+      }(exports, function() {
+        "use strict";
+        var e = { LTS: "h:mm:ss A", LT: "h:mm A", L: "MM/DD/YYYY", LL: "MMMM D, YYYY", LLL: "MMMM D, YYYY h:mm A", LLLL: "dddd, MMMM D, YYYY h:mm A" };
+        return function(t, o, n) {
+          var r = o.prototype, i = r.format;
+          n.en.formats = e, r.format = function(t2) {
+            void 0 === t2 && (t2 = "YYYY-MM-DDTHH:mm:ssZ");
+            var o2 = this.$locale().formats, n2 = function(t3, o3) {
+              return t3.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, function(t4, n3, r2) {
+                var i2 = r2 && r2.toUpperCase();
+                return n3 || o3[r2] || e[r2] || o3[i2].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, function(e2, t5, o4) {
+                  return t5 || o4.slice(1);
+                });
+              });
+            }(t2, void 0 === o2 ? {} : o2);
+            return i.call(this, n2);
+          };
+        };
+      });
+    }
+  });
+
+  // node_modules/dayjs/plugin/utc.js
+  var require_utc = __commonJS({
+    "node_modules/dayjs/plugin/utc.js"(exports, module) {
+      !function(t, i) {
+        "object" == typeof exports && "undefined" != typeof module ? module.exports = i() : "function" == typeof define && define.amd ? define(i) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs_plugin_utc = i();
+      }(exports, function() {
+        "use strict";
+        var t = "minute", i = /[+-]\d\d(?::?\d\d)?/g, e = /([+-]|\d\d)/g;
+        return function(s, f, n) {
+          var u = f.prototype;
+          n.utc = function(t2) {
+            var i2 = { date: t2, utc: true, args: arguments };
+            return new f(i2);
+          }, u.utc = function(i2) {
+            var e2 = n(this.toDate(), { locale: this.$L, utc: true });
+            return i2 ? e2.add(this.utcOffset(), t) : e2;
+          }, u.local = function() {
+            return n(this.toDate(), { locale: this.$L, utc: false });
+          };
+          var o = u.parse;
+          u.parse = function(t2) {
+            t2.utc && (this.$u = true), this.$utils().u(t2.$offset) || (this.$offset = t2.$offset), o.call(this, t2);
+          };
+          var r = u.init;
+          u.init = function() {
+            if (this.$u) {
+              var t2 = this.$d;
+              this.$y = t2.getUTCFullYear(), this.$M = t2.getUTCMonth(), this.$D = t2.getUTCDate(), this.$W = t2.getUTCDay(), this.$H = t2.getUTCHours(), this.$m = t2.getUTCMinutes(), this.$s = t2.getUTCSeconds(), this.$ms = t2.getUTCMilliseconds();
+            } else
+              r.call(this);
+          };
+          var a = u.utcOffset;
+          u.utcOffset = function(s2, f2) {
+            var n2 = this.$utils().u;
+            if (n2(s2))
+              return this.$u ? 0 : n2(this.$offset) ? a.call(this) : this.$offset;
+            if ("string" == typeof s2 && (s2 = function(t2) {
+              void 0 === t2 && (t2 = "");
+              var s3 = t2.match(i);
+              if (!s3)
+                return null;
+              var f3 = ("" + s3[0]).match(e) || ["-", 0, 0], n3 = f3[0], u3 = 60 * +f3[1] + +f3[2];
+              return 0 === u3 ? 0 : "+" === n3 ? u3 : -u3;
+            }(s2), null === s2))
+              return this;
+            var u2 = Math.abs(s2) <= 16 ? 60 * s2 : s2, o2 = this;
+            if (f2)
+              return o2.$offset = u2, o2.$u = 0 === s2, o2;
+            if (0 !== s2) {
+              var r2 = this.$u ? this.toDate().getTimezoneOffset() : -1 * this.utcOffset();
+              (o2 = this.local().add(u2 + r2, t)).$offset = u2, o2.$x.$localOffset = r2;
+            } else
+              o2 = this.utc();
+            return o2;
+          };
+          var h = u.format;
+          u.format = function(t2) {
+            var i2 = t2 || (this.$u ? "YYYY-MM-DDTHH:mm:ss[Z]" : "");
+            return h.call(this, i2);
+          }, u.valueOf = function() {
+            var t2 = this.$utils().u(this.$offset) ? 0 : this.$offset + (this.$x.$localOffset || this.$d.getTimezoneOffset());
+            return this.$d.valueOf() - 6e4 * t2;
+          }, u.isUTC = function() {
+            return !!this.$u;
+          }, u.toISOString = function() {
+            return this.toDate().toISOString();
+          }, u.toString = function() {
+            return this.toDate().toUTCString();
+          };
+          var l = u.toDate;
+          u.toDate = function(t2) {
+            return "s" === t2 && this.$offset ? n(this.format("YYYY-MM-DD HH:mm:ss:SSS")).toDate() : l.call(this);
+          };
+          var c = u.diff;
+          u.diff = function(t2, i2, e2) {
+            if (t2 && this.$u === t2.$u)
+              return c.call(this, t2, i2, e2);
+            var s2 = this.local(), f2 = n(t2).local();
+            return c.call(s2, f2, i2, e2);
+          };
+        };
+      });
+    }
+  });
+
+  // node_modules/dayjs/plugin/timezone.js
+  var require_timezone = __commonJS({
+    "node_modules/dayjs/plugin/timezone.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_plugin_timezone = e();
+      }(exports, function() {
+        "use strict";
+        var t = { year: 0, month: 1, day: 2, hour: 3, minute: 4, second: 5 }, e = {};
+        return function(n, i, o) {
+          var r, a = function(t2, n2, i2) {
+            void 0 === i2 && (i2 = {});
+            var o2 = new Date(t2), r2 = function(t3, n3) {
+              void 0 === n3 && (n3 = {});
+              var i3 = n3.timeZoneName || "short", o3 = t3 + "|" + i3, r3 = e[o3];
+              return r3 || (r3 = new Intl.DateTimeFormat("en-US", { hour12: false, timeZone: t3, year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", second: "2-digit", timeZoneName: i3 }), e[o3] = r3), r3;
+            }(n2, i2);
+            return r2.formatToParts(o2);
+          }, u = function(e2, n2) {
+            for (var i2 = a(e2, n2), r2 = [], u2 = 0; u2 < i2.length; u2 += 1) {
+              var f2 = i2[u2], s2 = f2.type, m = f2.value, c = t[s2];
+              c >= 0 && (r2[c] = parseInt(m, 10));
+            }
+            var d = r2[3], l = 24 === d ? 0 : d, v = r2[0] + "-" + r2[1] + "-" + r2[2] + " " + l + ":" + r2[4] + ":" + r2[5] + ":000", h = +e2;
+            return (o.utc(v).valueOf() - (h -= h % 1e3)) / 6e4;
+          }, f = i.prototype;
+          f.tz = function(t2, e2) {
+            void 0 === t2 && (t2 = r);
+            var n2 = this.utcOffset(), i2 = this.toDate(), a2 = i2.toLocaleString("en-US", { timeZone: t2 }), u2 = Math.round((i2 - new Date(a2)) / 1e3 / 60), f2 = o(a2).$set("millisecond", this.$ms).utcOffset(15 * -Math.round(i2.getTimezoneOffset() / 15) - u2, true);
+            if (e2) {
+              var s2 = f2.utcOffset();
+              f2 = f2.add(n2 - s2, "minute");
+            }
+            return f2.$x.$timezone = t2, f2;
+          }, f.offsetName = function(t2) {
+            var e2 = this.$x.$timezone || o.tz.guess(), n2 = a(this.valueOf(), e2, { timeZoneName: t2 }).find(function(t3) {
+              return "timezonename" === t3.type.toLowerCase();
+            });
+            return n2 && n2.value;
+          };
+          var s = f.startOf;
+          f.startOf = function(t2, e2) {
+            if (!this.$x || !this.$x.$timezone)
+              return s.call(this, t2, e2);
+            var n2 = o(this.format("YYYY-MM-DD HH:mm:ss:SSS"));
+            return s.call(n2, t2, e2).tz(this.$x.$timezone, true);
+          }, o.tz = function(t2, e2, n2) {
+            var i2 = n2 && e2, a2 = n2 || e2 || r, f2 = u(+o(), a2);
+            if ("string" != typeof t2)
+              return o(t2).tz(a2);
+            var s2 = function(t3, e3, n3) {
+              var i3 = t3 - 60 * e3 * 1e3, o2 = u(i3, n3);
+              if (e3 === o2)
+                return [i3, e3];
+              var r2 = u(i3 -= 60 * (o2 - e3) * 1e3, n3);
+              return o2 === r2 ? [i3, o2] : [t3 - 60 * Math.min(o2, r2) * 1e3, Math.max(o2, r2)];
+            }(o.utc(t2, i2).valueOf(), f2, a2), m = s2[0], c = s2[1], d = o(m).utcOffset(c);
+            return d.$x.$timezone = a2, d;
+          }, o.tz.guess = function() {
+            return Intl.DateTimeFormat().resolvedOptions().timeZone;
+          }, o.tz.setDefault = function(t2) {
+            r = t2;
+          };
+        };
+      });
+    }
+  });
+
+  // node_modules/dayjs/plugin/isBetween.js
+  var require_isBetween = __commonJS({
+    "node_modules/dayjs/plugin/isBetween.js"(exports, module) {
+      !function(e, i) {
+        "object" == typeof exports && "undefined" != typeof module ? module.exports = i() : "function" == typeof define && define.amd ? define(i) : (e = "undefined" != typeof globalThis ? globalThis : e || self).dayjs_plugin_isBetween = i();
+      }(exports, function() {
+        "use strict";
+        return function(e, i, t) {
+          i.prototype.isBetween = function(e2, i2, s, f) {
+            var n = t(e2), o = t(i2), r = "(" === (f = f || "()")[0], u = ")" === f[1];
+            return (r ? this.isAfter(n, s) : !this.isBefore(n, s)) && (u ? this.isBefore(o, s) : !this.isAfter(o, s)) || (r ? this.isBefore(n, s) : !this.isAfter(n, s)) && (u ? this.isAfter(o, s) : !this.isBefore(o, s));
+          };
+        };
+      });
+    }
+  });
+
+  // node_modules/dayjs/plugin/weekOfYear.js
+  var require_weekOfYear = __commonJS({
+    "node_modules/dayjs/plugin/weekOfYear.js"(exports, module) {
+      !function(e, t) {
+        "object" == typeof exports && "undefined" != typeof module ? module.exports = t() : "function" == typeof define && define.amd ? define(t) : (e = "undefined" != typeof globalThis ? globalThis : e || self).dayjs_plugin_weekOfYear = t();
+      }(exports, function() {
+        "use strict";
+        var e = "week", t = "year";
+        return function(i, n, r) {
+          var f = n.prototype;
+          f.week = function(i2) {
+            if (void 0 === i2 && (i2 = null), null !== i2)
+              return this.add(7 * (i2 - this.week()), "day");
+            var n2 = this.$locale().yearStart || 1;
+            if (11 === this.month() && this.date() > 25) {
+              var f2 = r(this).startOf(t).add(1, t).date(n2), s = r(this).endOf(e);
+              if (f2.isBefore(s))
+                return 1;
+            }
+            var a = r(this).startOf(t).date(n2).startOf(e).subtract(1, "millisecond"), o = this.diff(a, e, true);
+            return o < 0 ? r(this).startOf("week").week() : Math.ceil(o);
+          }, f.weeks = function(e2) {
+            return void 0 === e2 && (e2 = null), this.week(e2);
+          };
+        };
+      });
+    }
+  });
+
+  // node_modules/dayjs/plugin/quarterOfYear.js
+  var require_quarterOfYear = __commonJS({
+    "node_modules/dayjs/plugin/quarterOfYear.js"(exports, module) {
+      !function(t, n) {
+        "object" == typeof exports && "undefined" != typeof module ? module.exports = n() : "function" == typeof define && define.amd ? define(n) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs_plugin_quarterOfYear = n();
+      }(exports, function() {
+        "use strict";
+        var t = "month", n = "quarter";
+        return function(e, i) {
+          var r = i.prototype;
+          r.quarter = function(t2) {
+            return this.$utils().u(t2) ? Math.ceil((this.month() + 1) / 3) : this.month(this.month() % 3 + 3 * (t2 - 1));
+          };
+          var s = r.add;
+          r.add = function(e2, i2) {
+            return e2 = Number(e2), this.$utils().p(i2) === n ? this.add(3 * e2, t) : s.bind(this)(e2, i2);
+          };
+          var u = r.startOf;
+          r.startOf = function(e2, i2) {
+            var r2 = this.$utils(), s2 = !!r2.u(i2) || i2;
+            if (r2.p(e2) === n) {
+              var o = this.quarter() - 1;
+              return s2 ? this.month(3 * o).startOf(t).startOf("day") : this.month(3 * o + 2).endOf(t).endOf("day");
+            }
+            return u.bind(this)(e2, i2);
+          };
+        };
+      });
+    }
+  });
+
+  // node_modules/dayjs/plugin/customParseFormat.js
+  var require_customParseFormat = __commonJS({
+    "node_modules/dayjs/plugin/customParseFormat.js"(exports, module) {
+      !function(e, t) {
+        "object" == typeof exports && "undefined" != typeof module ? module.exports = t() : "function" == typeof define && define.amd ? define(t) : (e = "undefined" != typeof globalThis ? globalThis : e || self).dayjs_plugin_customParseFormat = t();
+      }(exports, function() {
+        "use strict";
+        var e = { LTS: "h:mm:ss A", LT: "h:mm A", L: "MM/DD/YYYY", LL: "MMMM D, YYYY", LLL: "MMMM D, YYYY h:mm A", LLLL: "dddd, MMMM D, YYYY h:mm A" }, t = /(\[[^[]*\])|([-_:/.,()\s]+)|(A|a|YYYY|YY?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g, n = /\d\d/, r = /\d\d?/, i = /\d*[^-_:/,()\s\d]+/, o = {}, s = function(e2) {
+          return (e2 = +e2) + (e2 > 68 ? 1900 : 2e3);
+        };
+        var a = function(e2) {
+          return function(t2) {
+            this[e2] = +t2;
+          };
+        }, f = [/[+-]\d\d:?(\d\d)?|Z/, function(e2) {
+          (this.zone || (this.zone = {})).offset = function(e3) {
+            if (!e3)
+              return 0;
+            if ("Z" === e3)
+              return 0;
+            var t2 = e3.match(/([+-]|\d\d)/g), n2 = 60 * t2[1] + (+t2[2] || 0);
+            return 0 === n2 ? 0 : "+" === t2[0] ? -n2 : n2;
+          }(e2);
+        }], h = function(e2) {
+          var t2 = o[e2];
+          return t2 && (t2.indexOf ? t2 : t2.s.concat(t2.f));
+        }, u = function(e2, t2) {
+          var n2, r2 = o.meridiem;
+          if (r2) {
+            for (var i2 = 1; i2 <= 24; i2 += 1)
+              if (e2.indexOf(r2(i2, 0, t2)) > -1) {
+                n2 = i2 > 12;
+                break;
+              }
+          } else
+            n2 = e2 === (t2 ? "pm" : "PM");
+          return n2;
+        }, d = { A: [i, function(e2) {
+          this.afternoon = u(e2, false);
+        }], a: [i, function(e2) {
+          this.afternoon = u(e2, true);
+        }], S: [/\d/, function(e2) {
+          this.milliseconds = 100 * +e2;
+        }], SS: [n, function(e2) {
+          this.milliseconds = 10 * +e2;
+        }], SSS: [/\d{3}/, function(e2) {
+          this.milliseconds = +e2;
+        }], s: [r, a("seconds")], ss: [r, a("seconds")], m: [r, a("minutes")], mm: [r, a("minutes")], H: [r, a("hours")], h: [r, a("hours")], HH: [r, a("hours")], hh: [r, a("hours")], D: [r, a("day")], DD: [n, a("day")], Do: [i, function(e2) {
+          var t2 = o.ordinal, n2 = e2.match(/\d+/);
+          if (this.day = n2[0], t2)
+            for (var r2 = 1; r2 <= 31; r2 += 1)
+              t2(r2).replace(/\[|\]/g, "") === e2 && (this.day = r2);
+        }], M: [r, a("month")], MM: [n, a("month")], MMM: [i, function(e2) {
+          var t2 = h("months"), n2 = (h("monthsShort") || t2.map(function(e3) {
+            return e3.slice(0, 3);
+          })).indexOf(e2) + 1;
+          if (n2 < 1)
+            throw new Error();
+          this.month = n2 % 12 || n2;
+        }], MMMM: [i, function(e2) {
+          var t2 = h("months").indexOf(e2) + 1;
+          if (t2 < 1)
+            throw new Error();
+          this.month = t2 % 12 || t2;
+        }], Y: [/[+-]?\d+/, a("year")], YY: [n, function(e2) {
+          this.year = s(e2);
+        }], YYYY: [/\d{4}/, a("year")], Z: f, ZZ: f };
+        function c(n2) {
+          var r2, i2;
+          r2 = n2, i2 = o && o.formats;
+          for (var s2 = (n2 = r2.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, function(t2, n3, r3) {
+            var o2 = r3 && r3.toUpperCase();
+            return n3 || i2[r3] || e[r3] || i2[o2].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, function(e2, t3, n4) {
+              return t3 || n4.slice(1);
+            });
+          })).match(t), a2 = s2.length, f2 = 0; f2 < a2; f2 += 1) {
+            var h2 = s2[f2], u2 = d[h2], c2 = u2 && u2[0], l = u2 && u2[1];
+            s2[f2] = l ? { regex: c2, parser: l } : h2.replace(/^\[|\]$/g, "");
+          }
+          return function(e2) {
+            for (var t2 = {}, n3 = 0, r3 = 0; n3 < a2; n3 += 1) {
+              var i3 = s2[n3];
+              if ("string" == typeof i3)
+                r3 += i3.length;
+              else {
+                var o2 = i3.regex, f3 = i3.parser, h3 = e2.slice(r3), u3 = o2.exec(h3)[0];
+                f3.call(t2, u3), e2 = e2.replace(u3, "");
+              }
+            }
+            return function(e3) {
+              var t3 = e3.afternoon;
+              if (void 0 !== t3) {
+                var n4 = e3.hours;
+                t3 ? n4 < 12 && (e3.hours += 12) : 12 === n4 && (e3.hours = 0), delete e3.afternoon;
+              }
+            }(t2), t2;
+          };
+        }
+        return function(e2, t2, n2) {
+          n2.p.customParseFormat = true, e2 && e2.parseTwoDigitYear && (s = e2.parseTwoDigitYear);
+          var r2 = t2.prototype, i2 = r2.parse;
+          r2.parse = function(e3) {
+            var t3 = e3.date, r3 = e3.utc, s2 = e3.args;
+            this.$u = r3;
+            var a2 = s2[1];
+            if ("string" == typeof a2) {
+              var f2 = true === s2[2], h2 = true === s2[3], u2 = f2 || h2, d2 = s2[2];
+              h2 && (d2 = s2[2]), o = this.$locale(), !f2 && d2 && (o = n2.Ls[d2]), this.$d = function(e4, t4, n3) {
+                try {
+                  if (["x", "X"].indexOf(t4) > -1)
+                    return new Date(("X" === t4 ? 1e3 : 1) * e4);
+                  var r4 = c(t4)(e4), i3 = r4.year, o2 = r4.month, s3 = r4.day, a3 = r4.hours, f3 = r4.minutes, h3 = r4.seconds, u3 = r4.milliseconds, d3 = r4.zone, l2 = /* @__PURE__ */ new Date(), m2 = s3 || (i3 || o2 ? 1 : l2.getDate()), M2 = i3 || l2.getFullYear(), Y = 0;
+                  i3 && !o2 || (Y = o2 > 0 ? o2 - 1 : l2.getMonth());
+                  var p = a3 || 0, v = f3 || 0, D = h3 || 0, g = u3 || 0;
+                  return d3 ? new Date(Date.UTC(M2, Y, m2, p, v, D, g + 60 * d3.offset * 1e3)) : n3 ? new Date(Date.UTC(M2, Y, m2, p, v, D, g)) : new Date(M2, Y, m2, p, v, D, g);
+                } catch (e5) {
+                  return /* @__PURE__ */ new Date("");
+                }
+              }(t3, a2, r3), this.init(), d2 && true !== d2 && (this.$L = this.locale(d2).$L), u2 && t3 != this.format(a2) && (this.$d = /* @__PURE__ */ new Date("")), o = {};
+            } else if (a2 instanceof Array)
+              for (var l = a2.length, m = 1; m <= l; m += 1) {
+                s2[1] = a2[m - 1];
+                var M = n2.apply(this, s2);
+                if (M.isValid()) {
+                  this.$d = M.$d, this.$L = M.$L, this.init();
+                  break;
+                }
+                m === l && (this.$d = /* @__PURE__ */ new Date(""));
+              }
+            else
+              i2.call(this, e3);
+          };
+        };
+      });
+    }
+  });
+
+  // node_modules/dayjs/plugin/isSameOrBefore.js
+  var require_isSameOrBefore = __commonJS({
+    "node_modules/dayjs/plugin/isSameOrBefore.js"(exports, module) {
+      !function(e, i) {
+        "object" == typeof exports && "undefined" != typeof module ? module.exports = i() : "function" == typeof define && define.amd ? define(i) : (e = "undefined" != typeof globalThis ? globalThis : e || self).dayjs_plugin_isSameOrBefore = i();
+      }(exports, function() {
+        "use strict";
+        return function(e, i) {
+          i.prototype.isSameOrBefore = function(e2, i2) {
+            return this.isSame(e2, i2) || this.isBefore(e2, i2);
+          };
+        };
+      });
+    }
+  });
+
+  // node_modules/dayjs/plugin/isToday.js
+  var require_isToday = __commonJS({
+    "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/lodash.isequal/index.js
+  var require_lodash = __commonJS({
+    "node_modules/lodash.isequal/index.js"(exports, module) {
+      var LARGE_ARRAY_SIZE = 200;
+      var HASH_UNDEFINED = "__lodash_hash_undefined__";
+      var COMPARE_PARTIAL_FLAG = 1;
+      var COMPARE_UNORDERED_FLAG = 2;
+      var MAX_SAFE_INTEGER = 9007199254740991;
+      var argsTag = "[object Arguments]";
+      var arrayTag = "[object Array]";
+      var asyncTag = "[object AsyncFunction]";
+      var boolTag = "[object Boolean]";
+      var dateTag = "[object Date]";
+      var errorTag = "[object Error]";
+      var funcTag = "[object Function]";
+      var genTag = "[object GeneratorFunction]";
+      var mapTag = "[object Map]";
+      var numberTag = "[object Number]";
+      var nullTag = "[object Null]";
+      var objectTag = "[object Object]";
+      var promiseTag = "[object Promise]";
+      var proxyTag = "[object Proxy]";
+      var regexpTag = "[object RegExp]";
+      var setTag = "[object Set]";
+      var stringTag = "[object String]";
+      var symbolTag = "[object Symbol]";
+      var undefinedTag = "[object Undefined]";
+      var weakMapTag = "[object WeakMap]";
+      var arrayBufferTag = "[object ArrayBuffer]";
+      var dataViewTag = "[object DataView]";
+      var float32Tag = "[object Float32Array]";
+      var float64Tag = "[object Float64Array]";
+      var int8Tag = "[object Int8Array]";
+      var int16Tag = "[object Int16Array]";
+      var int32Tag = "[object Int32Array]";
+      var uint8Tag = "[object Uint8Array]";
+      var uint8ClampedTag = "[object Uint8ClampedArray]";
+      var uint16Tag = "[object Uint16Array]";
+      var uint32Tag = "[object Uint32Array]";
+      var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+      var reIsHostCtor = /^\[object .+?Constructor\]$/;
+      var reIsUint = /^(?:0|[1-9]\d*)$/;
+      var typedArrayTags = {};
+      typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+      typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+      var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+      var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+      var root = freeGlobal || freeSelf || Function("return this")();
+      var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+      var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+      var moduleExports = freeModule && freeModule.exports === freeExports;
+      var freeProcess = moduleExports && freeGlobal.process;
+      var nodeUtil = function() {
+        try {
+          return freeProcess && freeProcess.binding && freeProcess.binding("util");
+        } catch (e) {
+        }
+      }();
+      var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+      function arrayFilter(array, predicate) {
+        var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+        while (++index < length) {
+          var value = array[index];
+          if (predicate(value, index, array)) {
+            result[resIndex++] = value;
+          }
+        }
+        return result;
+      }
+      function arrayPush(array, values) {
+        var index = -1, length = values.length, offset = array.length;
+        while (++index < length) {
+          array[offset + index] = values[index];
+        }
+        return array;
+      }
+      function arraySome(array, predicate) {
+        var index = -1, length = array == null ? 0 : array.length;
+        while (++index < length) {
+          if (predicate(array[index], index, array)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function baseTimes(n, iteratee) {
+        var index = -1, result = Array(n);
+        while (++index < n) {
+          result[index] = iteratee(index);
+        }
+        return result;
+      }
+      function baseUnary(func) {
+        return function(value) {
+          return func(value);
+        };
+      }
+      function cacheHas(cache, key) {
+        return cache.has(key);
+      }
+      function getValue(object, key) {
+        return object == null ? void 0 : object[key];
+      }
+      function mapToArray(map) {
+        var index = -1, result = Array(map.size);
+        map.forEach(function(value, key) {
+          result[++index] = [key, value];
+        });
+        return result;
+      }
+      function overArg(func, transform) {
+        return function(arg) {
+          return func(transform(arg));
+        };
+      }
+      function setToArray(set) {
+        var index = -1, result = Array(set.size);
+        set.forEach(function(value) {
+          result[++index] = value;
+        });
+        return result;
+      }
+      var arrayProto = Array.prototype;
+      var funcProto = Function.prototype;
+      var objectProto = Object.prototype;
+      var coreJsData = root["__core-js_shared__"];
+      var funcToString = funcProto.toString;
+      var hasOwnProperty = objectProto.hasOwnProperty;
+      var maskSrcKey = function() {
+        var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+        return uid ? "Symbol(src)_1." + uid : "";
+      }();
+      var nativeObjectToString = objectProto.toString;
+      var reIsNative = RegExp(
+        "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+      );
+      var Buffer2 = moduleExports ? root.Buffer : void 0;
+      var Symbol2 = root.Symbol;
+      var Uint8Array2 = root.Uint8Array;
+      var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+      var splice = arrayProto.splice;
+      var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
+      var nativeGetSymbols = Object.getOwnPropertySymbols;
+      var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
+      var nativeKeys = overArg(Object.keys, Object);
+      var DataView = getNative(root, "DataView");
+      var Map = getNative(root, "Map");
+      var Promise2 = getNative(root, "Promise");
+      var Set = getNative(root, "Set");
+      var WeakMap = getNative(root, "WeakMap");
+      var nativeCreate = getNative(Object, "create");
+      var dataViewCtorString = toSource(DataView);
+      var mapCtorString = toSource(Map);
+      var promiseCtorString = toSource(Promise2);
+      var setCtorString = toSource(Set);
+      var weakMapCtorString = toSource(WeakMap);
+      var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
+      var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+      function Hash(entries) {
+        var index = -1, length = entries == null ? 0 : entries.length;
+        this.clear();
+        while (++index < length) {
+          var entry = entries[index];
+          this.set(entry[0], entry[1]);
+        }
+      }
+      function hashClear() {
+        this.__data__ = nativeCreate ? nativeCreate(null) : {};
+        this.size = 0;
+      }
+      function hashDelete(key) {
+        var result = this.has(key) && delete this.__data__[key];
+        this.size -= result ? 1 : 0;
+        return result;
+      }
+      function hashGet(key) {
+        var data = this.__data__;
+        if (nativeCreate) {
+          var result = data[key];
+          return result === HASH_UNDEFINED ? void 0 : result;
+        }
+        return hasOwnProperty.call(data, key) ? data[key] : void 0;
+      }
+      function hashHas(key) {
+        var data = this.__data__;
+        return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+      }
+      function hashSet(key, value) {
+        var data = this.__data__;
+        this.size += this.has(key) ? 0 : 1;
+        data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+        return this;
+      }
+      Hash.prototype.clear = hashClear;
+      Hash.prototype["delete"] = hashDelete;
+      Hash.prototype.get = hashGet;
+      Hash.prototype.has = hashHas;
+      Hash.prototype.set = hashSet;
+      function ListCache(entries) {
+        var index = -1, length = entries == null ? 0 : entries.length;
+        this.clear();
+        while (++index < length) {
+          var entry = entries[index];
+          this.set(entry[0], entry[1]);
+        }
+      }
+      function listCacheClear() {
+        this.__data__ = [];
+        this.size = 0;
+      }
+      function listCacheDelete(key) {
+        var data = this.__data__, index = assocIndexOf(data, key);
+        if (index < 0) {
+          return false;
+        }
+        var lastIndex = data.length - 1;
+        if (index == lastIndex) {
+          data.pop();
+        } else {
+          splice.call(data, index, 1);
+        }
+        --this.size;
+        return true;
+      }
+      function listCacheGet(key) {
+        var data = this.__data__, index = assocIndexOf(data, key);
+        return index < 0 ? void 0 : data[index][1];
+      }
+      function listCacheHas(key) {
+        return assocIndexOf(this.__data__, key) > -1;
+      }
+      function listCacheSet(key, value) {
+        var data = this.__data__, index = assocIndexOf(data, key);
+        if (index < 0) {
+          ++this.size;
+          data.push([key, value]);
+        } else {
+          data[index][1] = value;
+        }
+        return this;
+      }
+      ListCache.prototype.clear = listCacheClear;
+      ListCache.prototype["delete"] = listCacheDelete;
+      ListCache.prototype.get = listCacheGet;
+      ListCache.prototype.has = listCacheHas;
+      ListCache.prototype.set = listCacheSet;
+      function MapCache(entries) {
+        var index = -1, length = entries == null ? 0 : entries.length;
+        this.clear();
+        while (++index < length) {
+          var entry = entries[index];
+          this.set(entry[0], entry[1]);
+        }
+      }
+      function mapCacheClear() {
+        this.size = 0;
+        this.__data__ = {
+          "hash": new Hash(),
+          "map": new (Map || ListCache)(),
+          "string": new Hash()
+        };
+      }
+      function mapCacheDelete(key) {
+        var result = getMapData(this, key)["delete"](key);
+        this.size -= result ? 1 : 0;
+        return result;
+      }
+      function mapCacheGet(key) {
+        return getMapData(this, key).get(key);
+      }
+      function mapCacheHas(key) {
+        return getMapData(this, key).has(key);
+      }
+      function mapCacheSet(key, value) {
+        var data = getMapData(this, key), size = data.size;
+        data.set(key, value);
+        this.size += data.size == size ? 0 : 1;
+        return this;
+      }
+      MapCache.prototype.clear = mapCacheClear;
+      MapCache.prototype["delete"] = mapCacheDelete;
+      MapCache.prototype.get = mapCacheGet;
+      MapCache.prototype.has = mapCacheHas;
+      MapCache.prototype.set = mapCacheSet;
+      function SetCache(values) {
+        var index = -1, length = values == null ? 0 : values.length;
+        this.__data__ = new MapCache();
+        while (++index < length) {
+          this.add(values[index]);
+        }
+      }
+      function setCacheAdd(value) {
+        this.__data__.set(value, HASH_UNDEFINED);
+        return this;
+      }
+      function setCacheHas(value) {
+        return this.__data__.has(value);
+      }
+      SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+      SetCache.prototype.has = setCacheHas;
+      function Stack(entries) {
+        var data = this.__data__ = new ListCache(entries);
+        this.size = data.size;
+      }
+      function stackClear() {
+        this.__data__ = new ListCache();
+        this.size = 0;
+      }
+      function stackDelete(key) {
+        var data = this.__data__, result = data["delete"](key);
+        this.size = data.size;
+        return result;
+      }
+      function stackGet(key) {
+        return this.__data__.get(key);
+      }
+      function stackHas(key) {
+        return this.__data__.has(key);
+      }
+      function stackSet(key, value) {
+        var data = this.__data__;
+        if (data instanceof ListCache) {
+          var pairs = data.__data__;
+          if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
+            pairs.push([key, value]);
+            this.size = ++data.size;
+            return this;
+          }
+          data = this.__data__ = new MapCache(pairs);
+        }
+        data.set(key, value);
+        this.size = data.size;
+        return this;
+      }
+      Stack.prototype.clear = stackClear;
+      Stack.prototype["delete"] = stackDelete;
+      Stack.prototype.get = stackGet;
+      Stack.prototype.has = stackHas;
+      Stack.prototype.set = stackSet;
+      function arrayLikeKeys(value, inherited) {
+        var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+        for (var key in value) {
+          if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+          (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+          isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+          isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+          isIndex(key, length)))) {
+            result.push(key);
+          }
+        }
+        return result;
+      }
+      function assocIndexOf(array, key) {
+        var length = array.length;
+        while (length--) {
+          if (eq(array[length][0], key)) {
+            return length;
+          }
+        }
+        return -1;
+      }
+      function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+        var result = keysFunc(object);
+        return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+      }
+      function baseGetTag(value) {
+        if (value == null) {
+          return value === void 0 ? undefinedTag : nullTag;
+        }
+        return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+      }
+      function baseIsArguments(value) {
+        return isObjectLike(value) && baseGetTag(value) == argsTag;
+      }
+      function baseIsEqual(value, other, bitmask, customizer, stack) {
+        if (value === other) {
+          return true;
+        }
+        if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
+          return value !== value && other !== other;
+        }
+        return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+      }
+      function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+        var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
+        objTag = objTag == argsTag ? objectTag : objTag;
+        othTag = othTag == argsTag ? objectTag : othTag;
+        var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+        if (isSameTag && isBuffer(object)) {
+          if (!isBuffer(other)) {
+            return false;
+          }
+          objIsArr = true;
+          objIsObj = false;
+        }
+        if (isSameTag && !objIsObj) {
+          stack || (stack = new Stack());
+          return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+        }
+        if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+          var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+          if (objIsWrapped || othIsWrapped) {
+            var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+            stack || (stack = new Stack());
+            return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+          }
+        }
+        if (!isSameTag) {
+          return false;
+        }
+        stack || (stack = new Stack());
+        return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+      }
+      function baseIsNative(value) {
+        if (!isObject2(value) || isMasked(value)) {
+          return false;
+        }
+        var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+        return pattern.test(toSource(value));
+      }
+      function baseIsTypedArray(value) {
+        return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+      }
+      function baseKeys(object) {
+        if (!isPrototype(object)) {
+          return nativeKeys(object);
+        }
+        var result = [];
+        for (var key in Object(object)) {
+          if (hasOwnProperty.call(object, key) && key != "constructor") {
+            result.push(key);
+          }
+        }
+        return result;
+      }
+      function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+        var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
+        if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+          return false;
+        }
+        var stacked = stack.get(array);
+        if (stacked && stack.get(other)) {
+          return stacked == other;
+        }
+        var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
+        stack.set(array, other);
+        stack.set(other, array);
+        while (++index < arrLength) {
+          var arrValue = array[index], othValue = other[index];
+          if (customizer) {
+            var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+          }
+          if (compared !== void 0) {
+            if (compared) {
+              continue;
+            }
+            result = false;
+            break;
+          }
+          if (seen) {
+            if (!arraySome(other, function(othValue2, othIndex) {
+              if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+                return seen.push(othIndex);
+              }
+            })) {
+              result = false;
+              break;
+            }
+          } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+            result = false;
+            break;
+          }
+        }
+        stack["delete"](array);
+        stack["delete"](other);
+        return result;
+      }
+      function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+        switch (tag) {
+          case dataViewTag:
+            if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+              return false;
+            }
+            object = object.buffer;
+            other = other.buffer;
+          case arrayBufferTag:
+            if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
+              return false;
+            }
+            return true;
+          case boolTag:
+          case dateTag:
+          case numberTag:
+            return eq(+object, +other);
+          case errorTag:
+            return object.name == other.name && object.message == other.message;
+          case regexpTag:
+          case stringTag:
+            return object == other + "";
+          case mapTag:
+            var convert = mapToArray;
+          case setTag:
+            var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+            convert || (convert = setToArray);
+            if (object.size != other.size && !isPartial) {
+              return false;
+            }
+            var stacked = stack.get(object);
+            if (stacked) {
+              return stacked == other;
+            }
+            bitmask |= COMPARE_UNORDERED_FLAG;
+            stack.set(object, other);
+            var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+            stack["delete"](object);
+            return result;
+          case symbolTag:
+            if (symbolValueOf) {
+              return symbolValueOf.call(object) == symbolValueOf.call(other);
+            }
+        }
+        return false;
+      }
+      function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+        var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
+        if (objLength != othLength && !isPartial) {
+          return false;
+        }
+        var index = objLength;
+        while (index--) {
+          var key = objProps[index];
+          if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+            return false;
+          }
+        }
+        var stacked = stack.get(object);
+        if (stacked && stack.get(other)) {
+          return stacked == other;
+        }
+        var result = true;
+        stack.set(object, other);
+        stack.set(other, object);
+        var skipCtor = isPartial;
+        while (++index < objLength) {
+          key = objProps[index];
+          var objValue = object[key], othValue = other[key];
+          if (customizer) {
+            var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+          }
+          if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+            result = false;
+            break;
+          }
+          skipCtor || (skipCtor = key == "constructor");
+        }
+        if (result && !skipCtor) {
+          var objCtor = object.constructor, othCtor = other.constructor;
+          if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+            result = false;
+          }
+        }
+        stack["delete"](object);
+        stack["delete"](other);
+        return result;
+      }
+      function getAllKeys(object) {
+        return baseGetAllKeys(object, keys, getSymbols);
+      }
+      function getMapData(map, key) {
+        var data = map.__data__;
+        return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+      }
+      function getNative(object, key) {
+        var value = getValue(object, key);
+        return baseIsNative(value) ? value : void 0;
+      }
+      function getRawTag(value) {
+        var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+        try {
+          value[symToStringTag] = void 0;
+          var unmasked = true;
+        } catch (e) {
+        }
+        var result = nativeObjectToString.call(value);
+        if (unmasked) {
+          if (isOwn) {
+            value[symToStringTag] = tag;
+          } else {
+            delete value[symToStringTag];
+          }
+        }
+        return result;
+      }
+      var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+        if (object == null) {
+          return [];
+        }
+        object = Object(object);
+        return arrayFilter(nativeGetSymbols(object), function(symbol) {
+          return propertyIsEnumerable.call(object, symbol);
+        });
+      };
+      var getTag = baseGetTag;
+      if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set && getTag(new Set()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {
+        getTag = function(value) {
+          var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+          if (ctorString) {
+            switch (ctorString) {
+              case dataViewCtorString:
+                return dataViewTag;
+              case mapCtorString:
+                return mapTag;
+              case promiseCtorString:
+                return promiseTag;
+              case setCtorString:
+                return setTag;
+              case weakMapCtorString:
+                return weakMapTag;
+            }
+          }
+          return result;
+        };
+      }
+      function isIndex(value, length) {
+        length = length == null ? MAX_SAFE_INTEGER : length;
+        return !!length && (typeof value == "number" || reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+      }
+      function isKeyable(value) {
+        var type = typeof value;
+        return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+      }
+      function isMasked(func) {
+        return !!maskSrcKey && maskSrcKey in func;
+      }
+      function isPrototype(value) {
+        var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
+        return value === proto;
+      }
+      function objectToString(value) {
+        return nativeObjectToString.call(value);
+      }
+      function toSource(func) {
+        if (func != null) {
+          try {
+            return funcToString.call(func);
+          } catch (e) {
+          }
+          try {
+            return func + "";
+          } catch (e) {
+          }
+        }
+        return "";
+      }
+      function eq(value, other) {
+        return value === other || value !== value && other !== other;
+      }
+      var isArguments = baseIsArguments(function() {
+        return arguments;
+      }()) ? baseIsArguments : function(value) {
+        return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+      };
+      var isArray = Array.isArray;
+      function isArrayLike(value) {
+        return value != null && isLength(value.length) && !isFunction(value);
+      }
+      var isBuffer = nativeIsBuffer || stubFalse;
+      function isEqual2(value, other) {
+        return baseIsEqual(value, other);
+      }
+      function isFunction(value) {
+        if (!isObject2(value)) {
+          return false;
+        }
+        var tag = baseGetTag(value);
+        return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+      }
+      function isLength(value) {
+        return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+      }
+      function isObject2(value) {
+        var type = typeof value;
+        return value != null && (type == "object" || type == "function");
+      }
+      function isObjectLike(value) {
+        return value != null && typeof value == "object";
+      }
+      var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+      function keys(object) {
+        return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+      }
+      function stubArray() {
+        return [];
+      }
+      function stubFalse() {
+        return false;
+      }
+      module.exports = isEqual2;
+    }
+  });
+
+  // src/HelperFns/objectHelpers.ts
+  var nameValueObject = (name, value) => {
+    return {
+      name,
+      value
+    };
+  };
+  var getKeyByValue = (object, value) => {
+    return Object.keys(object).find((key) => object[key] === value);
+  };
+
+  // src/HelperFns/columnHelpers.ts
+  var isColumnNumberType = (col) => {
+    const type = col == null ? void 0 : col.type;
+    return type === "DOLLAR_AMT" || type === "QUANTITY" || type === "PERCENT" || type === "RATIO";
+  };
+  var isColumnStringType = (col) => {
+    const type = col == null ? void 0 : col.type;
+    return type === "STRING" || type === "DATE_STRING" || type === "DATE" || type === "UNKNOWN";
+  };
+  var isColumnDateType = (col) => {
+    try {
+      const isDateType = col.type === "DATE" || col.type === "DATE_STRING";
+      return isDateType;
+    } catch (error) {
+      return false;
+    }
+  };
+  var hasNumberColumn = (columns) => {
+    var _a;
+    const hasNumberColumn2 = !!((_a = columns.filter((col) => isColumnNumberType(col))) == null ? void 0 : _a.length);
+    return hasNumberColumn2;
+  };
+  var hasStringColumn = (columns) => {
+    var _a;
+    const hasStringColumn2 = !!((_a = columns.filter((col) => isColumnStringType(col))) == null ? void 0 : _a.length);
+    return hasStringColumn2;
+  };
+  var hasDateColumn = (columns) => {
+    var _a;
+    const hasDateColumn2 = !!((_a = columns.filter((col) => isColumnDateType(col))) == null ? void 0 : _a.length);
+    return hasDateColumn2;
+  };
+  var getVisibleColumns = (columns) => {
+    return columns == null ? void 0 : columns.filter((col) => col == null ? void 0 : col.is_visible);
+  };
+  var getGroupableColumns = (columns) => {
+    const groupableColumns = [];
+    if (columns) {
+      columns.forEach((col, index) => {
+        if (col.groupable) {
+          groupableColumns.push(index);
+        }
+      });
+    }
+    return groupableColumns;
+  };
+  var getGroupBys = (row, columns) => {
+    if (!(columns == null ? void 0 : columns.length)) {
+      return void 0;
+    }
+    const groupableColumns = getGroupableColumns(columns);
+    const numGroupables = groupableColumns.length;
+    if (!numGroupables) {
+      return { groupBys: void 0, supportedByAPI: false };
+    }
+    const groupBys = [];
+    groupableColumns.forEach((colIndex) => {
+      const groupByName = columns[colIndex].name;
+      const groupByValue = `${row[colIndex]}`;
+      groupBys.push(nameValueObject(groupByName, groupByValue));
+    });
+    return { groupBys, supportedByAPI: true };
+  };
+  var getGroupBysFromTable = (cell, tableColumns) => {
+    if (!cell || !tableColumns) {
+      return void 0;
+    }
+    const groupableColumns = getGroupableColumns(tableColumns);
+    const numGroupables = groupableColumns.length;
+    if (!numGroupables) {
+      return void 0;
+    }
+    const rowData = cell.getData();
+    const groupByArray = [];
+    groupableColumns.forEach((colIndex) => {
+      const groupByName = tableColumns[colIndex].name;
+      const groupByValue = `${rowData[colIndex]}`;
+      groupByArray.push(nameValueObject(groupByName, groupByValue));
+    });
+    return groupByArray;
+  };
+  var getGroupBysFromPivotTable = ({
+    cell,
+    rowHeaders,
+    columnHeaders,
+    rowHeaderDefinition,
+    columnHeaderDefinition
+  }) => {
+    var _a;
+    try {
+      const columnName = columnHeaderDefinition.name;
+      const columnField = Number(cell.getField()) - 1;
+      const columnValue = getKeyByValue(columnHeaders, columnField);
+      const rowName = rowHeaderDefinition.name;
+      const rowIndex = ((_a = cell == null ? void 0 : cell.getRow()) == null ? void 0 : _a.getPosition()) - 1;
+      const rowValue = getKeyByValue(rowHeaders, rowIndex);
+      if (columnName && rowName && columnValue !== void 0 && rowValue !== void 0) {
+        return [
+          {
+            name: columnName,
+            value: `${columnValue}`
+          },
+          {
+            name: rowName,
+            value: `${rowValue}`
+          }
+        ];
+      }
+    } catch (error) {
+      console.error(error);
+    }
+    return void 0;
+  };
+  var isAggregation = (columns) => {
+    try {
+      let isAgg = false;
+      if (columns) {
+        isAgg = !!columns.find((col) => col.groupable);
+      }
+      return isAgg;
+    } catch (error) {
+      console.error(error);
+      return false;
+    }
+  };
+  var getColumnTypeAmounts = (columns) => {
+    let amountOfStringColumns = 0;
+    let amountOfNumberColumns = 0;
+    columns.forEach((col) => {
+      if (isColumnNumberType(col) && col.is_visible) {
+        amountOfNumberColumns += 1;
+      } else if (isColumnStringType(col) && col.is_visible) {
+        amountOfStringColumns += 1;
+      }
+    });
+    return { amountOfNumberColumns, amountOfStringColumns };
+  };
+  var getDateColumnIndex = (columns) => {
+    return columns.findIndex((col) => col.is_visible && (col.type === "DATE" || col.type === "DATE_STRING"));
+  };
+  var getNumberOfGroupables = (columns) => {
+    let numberOfGroupables = 0;
+    if (columns) {
+      columns.forEach((col) => {
+        if (col.groupable) {
+          numberOfGroupables += 1;
+        }
+      });
+    }
+    return numberOfGroupables;
+  };
+  var isListQuery = (columns) => {
+    return getNumberOfGroupables(columns) === 0;
+  };
+
+  // src/dayjsWithPlugins.ts
+  var import_dayjs = __toESM(require_dayjs_min());
+  var import_advancedFormat = __toESM(require_advancedFormat());
+  var import_localizedFormat = __toESM(require_localizedFormat());
+  var import_utc = __toESM(require_utc());
+  var import_timezone = __toESM(require_timezone());
+  var import_isBetween = __toESM(require_isBetween());
+  var import_weekOfYear = __toESM(require_weekOfYear());
+  var import_quarterOfYear = __toESM(require_quarterOfYear());
+  var import_customParseFormat = __toESM(require_customParseFormat());
+  var import_isSameOrBefore = __toESM(require_isSameOrBefore());
+  var import_isToday = __toESM(require_isToday());
+  import_dayjs.default.extend(import_utc.default);
+  import_dayjs.default.extend(import_isToday.default);
+  import_dayjs.default.extend(import_timezone.default);
+  import_dayjs.default.extend(import_isBetween.default);
+  import_dayjs.default.extend(import_weekOfYear.default);
+  import_dayjs.default.extend(import_quarterOfYear.default);
+  import_dayjs.default.extend(import_advancedFormat.default);
+  import_dayjs.default.extend(import_isSameOrBefore.default);
+  import_dayjs.default.extend(import_localizedFormat.default);
+  import_dayjs.default.extend(import_customParseFormat.default);
+  (function applyLocale() {
+    const specificLanguageCode = window.navigator.language || "en";
+    const genericLanguageCode = specificLanguageCode.split("-")[0];
+    try {
+      __require(`dayjs/locale/${specificLanguageCode}.js`);
+      import_dayjs.default.locale(specificLanguageCode);
+    } catch (error) {
+      try {
+        __require(`dayjs/locale/${genericLanguageCode}.js`);
+        import_dayjs.default.locale(genericLanguageCode);
+      } catch (error2) {
+      }
+    }
+  })();
+  var dayjsWithPlugins_default = import_dayjs.default;
+
+  // src/HelperFns/stringHelpers.ts
+  var capitalizeFirstChar = (string) => {
+    let capitalized = string;
+    try {
+      capitalized = string.charAt(0).toUpperCase() + string.slice(1);
+    } catch (error) {
+      console.error(error);
+    }
+    return capitalized;
+  };
+  var isNumber = (str) => {
+    return /^\d+$/.test(str);
+  };
+
+  // src/Constants/constants.ts
+  var TABLE_TYPES = [
+    "pivot_table",
+    "pivot_column",
+    "date_pivot",
+    "table",
+    "compare_table",
+    "compare_table_budget"
+  ];
+  var CHART_TYPES = [
+    "bar",
+    "bubble",
+    "chart",
+    "column",
+    "heatmap",
+    "line",
+    "pie",
+    "stacked_bar",
+    "stacked_column",
+    "stacked_line",
+    "column_line",
+    "histogram",
+    "scatterplot"
+  ];
+  var DATE_ONLY_CHART_TYPES = ["line", "stacked_line"];
+  var DOUBLE_AXIS_CHART_TYPES = ["column_line"];
+  var MONTH_NAMES = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ];
+  var DEFAULT_DATA_PAGE_SIZE = 500;
+  var MAX_DATA_PAGE_SIZE = 5e3;
+  var WEEKDAY_NAMES_MON = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+  var WEEKDAY_NAMES_SUN = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+  var DOW_STYLES = ["NUM_1_MON", "NUM_1_SUN", "NUM_0_MON", "NUM_0_SUN", "ALPHA_MON", "ALPHA_SUN"];
+  var SEASON_NAMES = ["SP", "SU", "FA", "HO"];
+  var DAYJS_PRECISION_FORMATS = {
+    DAY: "ll",
+    MONTH: "MMMM YYYY",
+    YEAR: "YYYY",
+    DATE_HOUR: "ll h:00A",
+    DATE_MINUTE: "ll h:mmA"
+  };
+  var DEFAULT_AGG_TYPE = "sum";
+  var AGG_TYPES = [
+    {
+      displayName: "Sum",
+      value: "sum",
+      unit: "inherit",
+      tooltip: "<strong>Sum:</strong> Values that have the same chart axis label will be added up."
+    },
+    {
+      displayName: "Avg",
+      value: "avg",
+      unit: "inherit",
+      tooltip: "<strong>Average:</strong> Values that have the same chart axis label will be averaged."
+    },
+    // {
+    //   displayName: 'Median',
+    //   value: 'median',
+    //   unit: 'inherit',
+    //   tooltip: 'The median (middle) value will be shown for all data points with same label.',
+    // },
+    // {
+    //   displayName: 'Minimum',
+    //   value: 'min',
+    //   unit: 'inherit',
+    //   tooltip: 'The smallest value will be shown for all data points with same label.',
+    // },
+    // {
+    //   displayName: 'Maximum',
+    //   value: 'max',
+    //   unit: 'inherit',
+    //   tooltip: 'The largest value will be shown for all data points with same label.',
+    // },
+    // {
+    //   displayName: 'Standard deviation',
+    //   value: 'deviation',
+    //   unit: 'none',
+    //   tooltip: 'The standard deviation will be shown for all data points with the same label.',
+    // },
+    // {
+    //   displayName: 'Variance',
+    //   value: 'variance',
+    //   unit: 'none',
+    //   tooltip: 'The variance will be shown for all data points with the same label.',
+    // },
+    {
+      displayName: "Count",
+      value: "count",
+      unit: "none",
+      tooltip: "<strong>Count:</strong> The total number of non-blank values will be shown for all data points with the same label."
+    }
+    // {
+    //   displayName: 'Distinct Count',
+    //   value: 'count-distinct',
+    //   unit: 'none',
+    // },
+  ];
+  var MAX_LEGEND_LABELS = 22;
+  var MIN_HISTOGRAM_SAMPLE = 20;
+
+  // src/Constants/enums.ts
+  var TimestampFormats = /* @__PURE__ */ ((TimestampFormats2) => {
+    TimestampFormats2["epoch"] = "EPOCH";
+    TimestampFormats2["iso8601"] = "ISO8601";
+    return TimestampFormats2;
+  })(TimestampFormats || {});
+  var PrecisionTypes = /* @__PURE__ */ ((PrecisionTypes2) => {
+    PrecisionTypes2["DAY"] = "DAY";
+    PrecisionTypes2["MONTH"] = "MONTH";
+    PrecisionTypes2["YEAR"] = "YEAR";
+    PrecisionTypes2["WEEK"] = "WEEK";
+    PrecisionTypes2["QUARTER"] = "QUARTER";
+    PrecisionTypes2["DATE_HOUR"] = "DATE_HOUR";
+    PrecisionTypes2["DATE_MINUTE"] = "DATE_MINUTE";
+    PrecisionTypes2["HOUR"] = "HOUR";
+    PrecisionTypes2["MINUTE"] = "MINUTE";
+    return PrecisionTypes2;
+  })(PrecisionTypes || {});
+  var NumberColumnTypes = /* @__PURE__ */ ((NumberColumnTypes2) => {
+    NumberColumnTypes2["CURRENCY"] = "DOLLAR_AMT";
+    NumberColumnTypes2["QUANTITY"] = "QUANTITY";
+    NumberColumnTypes2["RATIO"] = "RATIO";
+    NumberColumnTypes2["PERCENT"] = "PERCENT";
+    return NumberColumnTypes2;
+  })(NumberColumnTypes || {});
+  var NumberColumnTypeDisplayNames = /* @__PURE__ */ ((NumberColumnTypeDisplayNames2) => {
+    NumberColumnTypeDisplayNames2["DOLLAR_AMT"] = "Currency";
+    NumberColumnTypeDisplayNames2["QUANTITY"] = "Quantity";
+    NumberColumnTypeDisplayNames2["RATIO"] = "Ratio";
+    NumberColumnTypeDisplayNames2["PERCENT"] = "Percent";
+    return NumberColumnTypeDisplayNames2;
+  })(NumberColumnTypeDisplayNames || {});
+
+  // src/Constants/defaults.ts
+  var authenticationDefault = {
+    token: void 0,
+    apiKey: void 0,
+    domain: void 0,
+    dprKey: void 0,
+    dprDomain: void 0
+  };
+  var dataFormattingDefault = {
+    timestampFormat: "ISO8601" /* iso8601 */,
+    currencyCode: "USD",
+    languageCode: "en-US",
+    currencyDecimals: 2,
+    quantityDecimals: 2,
+    ratioDecimals: 4,
+    comparisonDisplay: "PERCENT",
+    monthYearFormat: "MMMM YYYY",
+    dayMonthYearFormat: "ll"
+  };
+  var autoQLConfigDefault = {
+    debug: false,
+    test: false,
+    enableAutocomplete: true,
+    enableQueryInterpretation: true,
+    enableQueryValidation: true,
+    enableQuerySuggestions: true,
+    enableColumnVisibilityManager: true,
+    enableDrilldowns: true,
+    enableNotifications: false,
+    enableCSVDownload: true,
+    enableReportProblem: true
+  };
+  var dataConfigDefault = {
+    stringColumnIndices: [],
+    numberColumnIndices: [],
+    stringColumnIndex: 0,
+    legendColumnIndex: void 0,
+    numberColumnIndex: 1
+  };
+  var getAuthentication = (prop = {}) => {
+    return {
+      ...authenticationDefault,
+      ...prop
+    };
+  };
+  var getDataFormatting = (prop = {}) => {
+    return {
+      ...dataFormattingDefault,
+      ...prop
+    };
+  };
+  var getAutoQLConfig = (prop = {}) => {
+    return {
+      ...autoQLConfigDefault,
+      ...prop
+    };
+  };
+  var getDataConfig = (prop = {}) => {
+    return {
+      ...dataConfigDefault,
+      ...prop
+    };
+  };
+
+  // src/HelperFns/dataFormattingHelpers.ts
+  var formatStringDateWithPrecision = (value, col) => {
+    if (!value) {
+      return void 0;
+    }
+    let formattedValue = value;
+    try {
+      switch (col.precision) {
+        case "DOW": {
+          formattedValue = formatDOW(value, col);
+          break;
+        }
+        case "HOUR": {
+          const dayjsTime = dayjsWithPlugins_default.utc(value, "THH:mm:ss.SSSZ").utc();
+          if (dayjsTime.isValid()) {
+            formattedValue = dayjsTime.format("h:00A");
+          }
+          break;
+        }
+        case "MINUTE": {
+          const dayjsTime = dayjsWithPlugins_default.utc(value, "THH:mm:ss.SSSZ").utc();
+          if (dayjsTime.isValid()) {
+            formattedValue = dayjsTime.format("h:mmA");
+          }
+          break;
+        }
+        case "MONTH": {
+          formattedValue = value;
+          break;
+        }
+        default: {
+          formattedValue = value;
+          break;
+        }
+      }
+      return formattedValue;
+    } catch (error) {
+      console.error(error);
+      return value;
+    }
+  };
+  var formatStringDate = (value, config = dataFormattingDefault) => {
+    var _a;
+    if (!value) {
+      return void 0;
+    }
+    if (value && typeof value === "string") {
+      const dateArray = value.split("-");
+      const year = dateArray == null ? void 0 : dateArray[0];
+      const day = dateArray == null ? void 0 : dateArray[2];
+      let month;
+      let week;
+      if ((_a = dateArray == null ? void 0 : dateArray[1]) == null ? void 0 : _a.includes("W")) {
+        week = dateArray == null ? void 0 : dateArray[1];
+      } else {
+        month = dateArray == null ? void 0 : dateArray[1];
+      }
+      const { monthYearFormat, dayMonthYearFormat } = getDataFormatting(config);
+      const dayJSObj = dayjsWithPlugins_default.utc(value).utc();
+      if (!dayJSObj.isValid()) {
+        return value;
+      }
+      let date = value;
+      if (day) {
+        date = dayJSObj.format(dayMonthYearFormat);
+      } else if (month) {
+        date = dayJSObj.format(monthYearFormat);
+      } else if (week) {
+      } else if (year) {
+        date = year;
+      }
+      return date;
+    }
+    return value;
+  };
+  var formatDateType = (element, column, config = dataFormattingDefault) => {
+    if (isNumber(element)) {
+      return formatEpochDate(element, column, config);
+    }
+    return formatISODateWithPrecision(element, column, config);
+  };
+  var formatDateStringType = (element, column, config = dataFormattingDefault) => {
+    if (!column) {
+      return element;
+    }
+    if (column.precision) {
+      return formatStringDateWithPrecision(element, column);
+    }
+    return formatStringDate(element, config);
+  };
+  var formatISODateWithPrecision = (value, col, config = dataFormattingDefault) => {
+    if (!value) {
+      return void 0;
+    }
+    if (!col) {
+      return value;
+    }
+    const precision = col.precision;
+    const { dayMonthYearFormat, monthYearFormat } = getDataFormatting(config);
+    const dateDayJS = dayjsWithPlugins_default.utc(value).utc();
+    if (!dateDayJS.isValid()) {
+      return value;
+    }
+    let date = dateDayJS.format(dayMonthYearFormat);
+    try {
+      switch (precision) {
+        case "DAY" /* DAY */: {
+          break;
+        }
+        case "WEEK" /* WEEK */: {
+          const dateJSStart = dateDayJS.startOf("week").format("MMM D");
+          const dateJSEnd = dateDayJS.endOf("week").format("MMM D");
+          const week = dateDayJS.week();
+          const year = dateDayJS.format("YYYY");
+          date = `${dateJSStart} - ${dateJSEnd}, ${year} (Week ${week})`;
+          break;
+        }
+        case "MONTH" /* MONTH */: {
+          date = dateDayJS.format(monthYearFormat);
+          break;
+        }
+        case "QUARTER" /* QUARTER */: {
+          const quarter = dateDayJS.quarter();
+          const year = dateDayJS.format("YYYY");
+          date = `${year}-Q${quarter}`;
+          break;
+        }
+        case "YEAR" /* YEAR */: {
+          date = dateDayJS.format("YYYY");
+          break;
+        }
+        case "DATE_HOUR" /* DATE_HOUR */: {
+          date = dateDayJS.format(`${dayMonthYearFormat} h:00A`);
+          break;
+        }
+        case "DATE_MINUTE" /* DATE_MINUTE */: {
+          date = dateDayJS.format(`${dayMonthYearFormat} h:mmA`);
+          break;
+        }
+        default: {
+          break;
+        }
+      }
+      return date;
+    } catch (error) {
+      console.error(error);
+    }
+  };
+  var formatEpochDate = (value, col, config = dataFormattingDefault) => {
+    if (!value) {
+      return void 0;
+    }
+    if (!col) {
+      return value;
+    }
+    try {
+      const { monthYearFormat, dayMonthYearFormat } = getDataFormatting(config);
+      const year = "YYYY";
+      const monthYear = monthYearFormat;
+      const dayMonthYear = dayMonthYearFormat;
+      const title = col.title;
+      let dayJSObj;
+      if (isNaN(parseFloat(value))) {
+        dayJSObj = dayjsWithPlugins_default.utc(value).utc();
+      } else {
+        dayJSObj = dayjsWithPlugins_default.unix(value).utc();
+      }
+      if (!dayJSObj.isValid()) {
+        return value;
+      }
+      let date = dayJSObj.format(dayMonthYear);
+      if (isNaN(parseFloat(value))) {
+        if (title && title.toLowerCase().includes("year")) {
+          date = dayJSObj.format(year);
+        } else if (title && title.toLowerCase().includes("month")) {
+          date = dayJSObj.format(monthYear);
+        }
+        date = dayJSObj.format(dayMonthYear);
+      } else if (title && title.toLowerCase().includes("year")) {
+        date = dayJSObj.format(year);
+      } else if (title && title.toLowerCase().includes("month")) {
+        date = dayJSObj.format(monthYear);
+      }
+      return date;
+    } catch (error) {
+      console.error(error);
+      return value;
+    }
+  };
+  var formatDOW = (value, col) => {
+    let dowStyle = col.dow_style;
+    if (!dowStyle) {
+      dowStyle = "NUM_1_MON";
+    }
+    let formattedValue = value;
+    let weekdayNumber = Number(value);
+    switch (dowStyle) {
+      case "NUM_1_MON": {
+        const weekdays = WEEKDAY_NAMES_MON;
+        const index = weekdayNumber - 1;
+        if (index >= 0) {
+          formattedValue = weekdays[index];
+        } else {
+          console.warn(`dow style is NUM_1_MON but the value could not be converted to a number: ${value}`);
+        }
+        break;
+      }
+      case "NUM_1_SUN": {
+        const weekdays = WEEKDAY_NAMES_SUN;
+        const index = weekdayNumber - 1;
+        if (index >= 0) {
+          formattedValue = weekdays[index];
+        } else {
+          console.warn(`dow style is NUM_1_SUN but the value could not be converted to a number: ${value}`);
+        }
+        break;
+      }
+      case "NUM_0_MON": {
+        const weekdays = WEEKDAY_NAMES_MON;
+        if (weekdayNumber >= 0) {
+          formattedValue = weekdays[weekdayNumber];
+        } else {
+          console.warn(`dow style is NUM_0_MON but the value could not be converted to a number: ${value}`);
+        }
+        break;
+      }
+      case "NUM_0_SUN": {
+        const weekdays = WEEKDAY_NAMES_SUN;
+        if (weekdayNumber >= 0) {
+          formattedValue = weekdays[weekdayNumber];
+        } else {
+          console.warn(`dow style is NUM_0_SUN but the value could not be converted to a number: ${value}`);
+        }
+        break;
+      }
+      case "ALPHA_MON":
+      case "ALPHA_SUN": {
+        const weekday = WEEKDAY_NAMES_MON.find((weekday2) => weekday2.toLowerCase().includes(value.trim().toLowerCase()));
+        if (weekday) {
+          formattedValue = weekday;
+        } else {
+          console.warn(`dow style is ALPHA but the value could not be matched to a weekday name: ${value}`);
+        }
+        break;
+      }
+      default: {
+        console.warn(`could not format dow value. dow_style was not recognized: ${col.dow_style}`);
+        break;
+      }
+    }
+    return formattedValue;
+  };
+  var dateStringSortFnWithoutPrecision = (a, b) => {
+    if (a.includes("-W")) {
+      const aDateYear = a.substring(0, 4);
+      const bDateYear = b.substring(0, 4);
+      if (aDateYear !== bDateYear) {
+        return aDateYear - bDateYear;
+      } else {
+        const aDateWeek = a.substring(6, 8);
+        const bDateWeek = b.substring(6, 8);
+        return aDateWeek - bDateWeek;
+      }
+    } else if (WEEKDAY_NAMES_MON.includes(a.trim())) {
+      const aDayIndex = WEEKDAY_NAMES_MON.findIndex((d) => d.toLowerCase().includes(a.trim().toLowerCase()));
+      const bDayIndex = WEEKDAY_NAMES_MON.findIndex((d) => d.toLowerCase().includes(b.trim().toLowerCase()));
+      let sortValue = a - b;
+      if (aDayIndex >= 0 && bDayIndex >= 0) {
+        sortValue = aDayIndex - bDayIndex;
+      }
+      return sortValue;
+    } else if (MONTH_NAMES.includes(a.trim())) {
+      const aMonthIndex = MONTH_NAMES.findIndex((m) => m === a.trim());
+      const bMonthIndex = MONTH_NAMES.findIndex((m) => m === b.trim());
+      if (aMonthIndex >= 0 && bMonthIndex >= 0) {
+        return bMonthIndex - aMonthIndex;
+      }
+      return a - b;
+    } else if (SEASON_NAMES.includes(a.substr(0, 2))) {
+      const aSeasonIndex = SEASON_NAMES.findIndex((s) => s === a.substr(0, 2));
+      const bSeasonIndex = SEASON_NAMES.findIndex((s) => s === b.substr(0, 2));
+      const aYear = Number(a.substr(2));
+      const bYear = Number(b.substr(2));
+      if (aYear === bYear) {
+        return aSeasonIndex - bSeasonIndex;
+      }
+      return aYear - bYear;
+    }
+    return a - b;
+  };
+  var dateStringSortFn = (a, b, col) => {
+    if (typeof a !== "string" || typeof b !== "string" || !col) {
+      return a - b;
+    }
+    const aTrimmed = a.trim();
+    const bTrimmed = b.trim();
+    switch (col.precision) {
+      case "DOW": {
+        const dowStyle = col.dow_style ?? "ALPHA_MON";
+        let aIndex = WEEKDAY_NAMES_MON.findIndex((dow) => dow.toLowerCase().includes(aTrimmed.toLowerCase()));
+        let bIndex = WEEKDAY_NAMES_MON.findIndex((dow) => dow.toLowerCase().includes(bTrimmed.toLowerCase()));
+        if (dowStyle === "ALPHA_SUN") {
+          aIndex = WEEKDAY_NAMES_SUN.findIndex((dow) => dow.toLowerCase().includes(aTrimmed.toLowerCase()));
+          bIndex = WEEKDAY_NAMES_SUN.findIndex((dow) => dow.toLowerCase().includes(bTrimmed.toLowerCase()));
+        }
+        return aIndex - bIndex;
+      }
+      case "HOUR":
+      case "MINUTE": {
+        const aDayjsTime = dayjsWithPlugins_default.utc(aTrimmed, "THH:mm:ss.SSSZ").utc();
+        const bDayjsTime = dayjsWithPlugins_default.utc(bTrimmed, "THH:mm:ss.SSSZ").utc();
+        return aDayjsTime.unix() - bDayjsTime.unix();
+      }
+      case "MONTH": {
+        MONTH_NAMES;
+        const aMonthIndex = MONTH_NAMES.findIndex((m) => m.toLowerCase() === aTrimmed.toLowerCase());
+        const bMonthIndex = MONTH_NAMES.findIndex((m) => m.toLowerCase() === bTrimmed.toLowerCase());
+        return aMonthIndex - bMonthIndex;
+      }
+      default: {
+        return dateStringSortFnWithoutPrecision(aTrimmed, bTrimmed);
+      }
+    }
+  };
+  var dateSortFn = (a, b, col, isTable) => {
+    try {
+      if (!a && !b) {
+        return 0;
+      } else if (!a && b) {
+        return 1;
+      } else if (a && !b || !col) {
+        return -1;
+      }
+      let aDate = Number(a);
+      let bDate = Number(b);
+      let sortValue = aDate - bDate;
+      if (isNaN(aDate) || isNaN(bDate)) {
+        if (col.type === "DATE_STRING") {
+          sortValue = dateStringSortFn(a, b, col);
+        } else {
+          sortValue = dayjsWithPlugins_default.utc(a).unix() - dayjsWithPlugins_default.utc(b).unix();
+        }
+      }
+      if (isTable && col.precision === "DOW") {
+        sortValue = -1 * sortValue;
+      }
+      return sortValue;
+    } catch (error) {
+      console.error(error);
+      return -1;
+    }
+  };
+  var sortDataByDate = (data, tableColumns, sortDirection = "desc", isTable) => {
+    try {
+      if (!data || typeof data !== "object") {
+        throw new Error("Could not sort data by date - no data supplied");
+      }
+      const dateColumnIndex = getDateColumnIndex(tableColumns);
+      const dateColumn = tableColumns[dateColumnIndex];
+      if (dateColumnIndex >= 0) {
+        let multiplier = sortDirection === "desc" ? -1 : 1;
+        const sortedData = [...data].sort(
+          (a, b) => multiplier * dateSortFn(a[dateColumnIndex], b[dateColumnIndex], dateColumn, isTable)
+        );
+        return sortedData;
+      }
+    } catch (error) {
+      console.error(error);
+    }
+    return data;
+  };
+  var formatElement = ({
+    element,
+    column,
+    config = dataFormattingDefault,
+    htmlElement,
+    isChart = false
+  }) => {
+    try {
+      let formattedElement = element;
+      const { currencyCode, languageCode, currencyDecimals, quantityDecimals, ratioDecimals } = getDataFormatting(config);
+      let type = column == null ? void 0 : column.type;
+      if (isChart && ["count", "deviation", "variance"].includes(column == null ? void 0 : column.aggType)) {
+        type = "QUANTITY";
+      }
+      if (column) {
+        switch (type) {
+          case "STRING": {
+            break;
+          }
+          case "DOLLAR_AMT": {
+            const elementNumber = parseFloat(`${element}`);
+            if (!isNaN(elementNumber)) {
+              const currency = currencyCode || "USD";
+              const validatedCurrencyDecimals = currencyDecimals || currencyDecimals === 0 ? currencyDecimals : void 0;
+              try {
+                formattedElement = new Intl.NumberFormat(languageCode, {
+                  style: "currency",
+                  currency: `${currency}`,
+                  minimumFractionDigits: validatedCurrencyDecimals,
+                  maximumFractionDigits: validatedCurrencyDecimals
+                }).format(elementNumber);
+              } catch (error) {
+                console.error(error);
+                formattedElement = new Intl.NumberFormat(languageCode, {
+                  style: "currency",
+                  currency: "USD",
+                  minimumFractionDigits: validatedCurrencyDecimals,
+                  maximumFractionDigits: validatedCurrencyDecimals
+                }).format(elementNumber);
+              }
+            }
+            break;
+          }
+          case "QUANTITY": {
+            const validatedQuantityDecimals = !isNaN(quantityDecimals) ? quantityDecimals : 2;
+            const elementNumber = parseFloat(`${element}`);
+            if (!isNaN(elementNumber)) {
+              const numDecimals = elementNumber % 1 !== 0 ? validatedQuantityDecimals : 0;
+              formattedElement = new Intl.NumberFormat(languageCode, {
+                minimumFractionDigits: numDecimals,
+                maximumFractionDigits: numDecimals
+              }).format(elementNumber);
+            }
+            break;
+          }
+          case "DATE": {
+            formattedElement = formatDateType(element, column, config);
+            break;
+          }
+          case "DATE_STRING": {
+            formattedElement = formatDateStringType(element, column, config);
+            break;
+          }
+          case "RATIO": {
+            const numDecimals = !isNaN(ratioDecimals) ? ratioDecimals : 4;
+            const elementNumber = parseFloat(`${element}`);
+            if (!isNaN(elementNumber)) {
+              formattedElement = new Intl.NumberFormat(languageCode, {
+                minimumFractionDigits: numDecimals,
+                maximumFractionDigits: numDecimals
+              }).format(elementNumber);
+            }
+            break;
+          }
+          case "PERCENT": {
+            const elementNumber = parseFloat(`${element}`);
+            if (!isNaN(elementNumber)) {
+              const p = elementNumber / 100;
+              formattedElement = new Intl.NumberFormat(languageCode, {
+                style: "percent",
+                minimumFractionDigits: 2,
+                maximumFractionDigits: 2
+              }).format(p);
+              if (htmlElement) {
+                if (elementNumber < 0) {
+                  htmlElement.classList.add("comparison-value-negative");
+                } else if (elementNumber > 0) {
+                  htmlElement.classList.add("comparison-value-positive");
+                }
+              }
+            }
+            break;
+          }
+          default: {
+            break;
+          }
+        }
+      }
+      return formattedElement;
+    } catch (error) {
+      console.error(error);
+      return element;
+    }
+  };
+  var getNumberFormatConfig = (d, scale) => {
+    var _a, _b;
+    let minimumFractionDigits = 0;
+    let maximumFractionDigits = 0;
+    let notation;
+    const domainRange = ((_a = scale == null ? void 0 : scale.domain()) == null ? void 0 : _a[1]) - ((_b = scale == null ? void 0 : scale.domain()) == null ? void 0 : _b[0]);
+    const smallDomain = domainRange && domainRange < 10;
+    const absValue = Math.abs(d);
+    if (smallDomain) {
+      minimumFractionDigits = 2;
+      maximumFractionDigits = 2;
+    } else if (absValue >= 1e3) {
+      notation = "compact";
+      if (absValue > 1e9) {
+        maximumFractionDigits = 3;
+      } else if (absValue > 1e6) {
+        maximumFractionDigits = 2;
+      } else if (absValue > 1e3) {
+        maximumFractionDigits = 1;
+      }
+    }
+    return { minimumFractionDigits, maximumFractionDigits, notation };
+  };
+  var formatChartLabel = ({ d, scale, column, dataFormatting, maxLabelWidth }) => {
+    if (d === null) {
+      return {
+        fullWidthLabel: "Untitled Category",
+        formattedLabel: "Untitled Category"
+      };
+    }
+    const col = column ?? (scale == null ? void 0 : scale.column);
+    if (!col || !col.type) {
+      return {
+        fullWidthLabel: d,
+        formattedLabel: d
+      };
+    }
+    const config = (scale == null ? void 0 : scale.dataFormatting) ?? dataFormatting;
+    const { currencyCode, languageCode } = config;
+    let type = col.type;
+    if ((scale == null ? void 0 : scale.units) === "none") {
+      type = "QUANTITY";
+    }
+    const { minimumFractionDigits, maximumFractionDigits, notation } = getNumberFormatConfig(d, scale);
+    let formattedLabel = d;
+    if (scale == null ? void 0 : scale.showLabelDecimals) {
+      formattedLabel = formatElement({
+        element: d,
+        column: column ?? (scale == null ? void 0 : scale.column),
+        config: dataFormatting,
+        isChart: true
+      });
+    } else {
+      switch (type) {
+        case "STRING": {
+          break;
+        }
+        case "DOLLAR_AMT": {
+          if (Number(d) || Number(d) === 0) {
+            const style = "currency";
+            const currency = currencyCode || "USD";
+            const currencyConfig = {
+              style,
+              minimumFractionDigits,
+              maximumFractionDigits,
+              notation
+            };
+            try {
+              formattedLabel = new Intl.NumberFormat(languageCode, {
+                ...currencyConfig,
+                currency
+              }).format(d);
+            } catch (error) {
+              console.error(error);
+              formattedLabel = new Intl.NumberFormat(languageCode, {
+                ...currencyConfig,
+                currency: "USD"
+              }).format(d);
+            }
+          }
+          break;
+        }
+        case "QUANTITY": {
+          if (!isNaN(parseFloat(d))) {
+            formattedLabel = new Intl.NumberFormat(languageCode, {
+              minimumFractionDigits,
+              maximumFractionDigits,
+              notation
+            }).format(d);
+          }
+          break;
+        }
+        case "DATE": {
+          formattedLabel = formatDateType(d, col, config);
+          break;
+        }
+        case "DATE_STRING": {
+          formattedLabel = formatDateStringType(d, col, config);
+          break;
+        }
+        case "PERCENT": {
+          if (Number(d) || Number(d) === 0) {
+            const p = Number(d) / 100;
+            formattedLabel = new Intl.NumberFormat(languageCode, {
+              style: "percent",
+              minimumFractionDigits: 1,
+              maximumFractionDigits: 1
+            }).format(p);
+          }
+          break;
+        }
+        default: {
+          break;
+        }
+      }
+    }
+    const fullWidthLabel = formattedLabel;
+    if (typeof formattedLabel === "string" && maxLabelWidth && formattedLabel.length > maxLabelWidth) {
+      formattedLabel = `${formattedLabel.substring(0, maxLabelWidth)}...`;
+    }
+    return { fullWidthLabel, formattedLabel };
+  };
+  var getCurrencySymbol = (dataFormatting = dataFormattingDefault) => {
+    var _a;
+    try {
+      const { currencyCode, languageCode } = getDataFormatting(dataFormatting);
+      const formattedParts = new Intl.NumberFormat(languageCode, {
+        style: "currency",
+        currency: currencyCode
+      }).formatToParts(0);
+      const symbol = (_a = formattedParts.find((part) => (part == null ? void 0 : part.type) === "currency")) == null ? void 0 : _a.value;
+      return symbol;
+    } catch (error) {
+      console.error(error);
+      return;
+    }
+  };
+  var getDayjsObjForStringType = (value, col) => {
+    if (!value) {
+      return void 0;
+    }
+    try {
+      switch (col.precision) {
+        case "DOW": {
+          return void 0;
+        }
+        case "HOUR":
+        case "MINUTE": {
+          return dayjsWithPlugins_default.utc(value, "THH:mm:ss.SSSZ").utc();
+        }
+        case "MONTH": {
+          return void 0;
+        }
+        default: {
+          return void 0;
+        }
+      }
+    } catch (error) {
+      console.error(error);
+      return void 0;
+    }
+  };
+  var getDayJSObj = ({ value, column }) => {
+    if (column.type === "DATE_STRING") {
+      return getDayjsObjForStringType(value, column);
+    }
+    if (isNumber(value)) {
+      return dayjsWithPlugins_default.unix(value).utc();
+    }
+    return dayjsWithPlugins_default.utc(value).utc();
+  };
+  var getEpochFromDate = (date, precision, precisionFrame) => {
+    if (date == null ? void 0 : date.getTime) {
+      if (precision && precisionFrame === "start") {
+        return dayjsWithPlugins_default(date).utc().startOf(precision).valueOf();
+      } else if (precision && precisionFrame === "end") {
+        return dayjsWithPlugins_default(date).utc().endOf(precision).valueOf();
+      }
+      return date.getTime();
+    }
+    return;
+  };
+
+  // src/HelperFns/arrayHelpers.ts
+  var import_lodash = __toESM(require_lodash());
+  var invertArray = (array) => {
+    const numRows = array.length;
+    const numColumns = array[0].length;
+    const invertedArray = [];
+    for (let i = 0; i < numColumns; i++) {
+      invertedArray[i] = [];
+      for (let j = 0; j < numRows; j++) {
+        if (array[j][i])
+          invertedArray[i][j] = array[j][i];
+      }
+    }
+    return invertedArray;
+  };
+  var functionsEqual = (a, b) => {
+    return (a == null ? void 0 : a.toString()) == (b == null ? void 0 : b.toString());
+  };
+  var isObject = (obj) => {
+    return typeof obj === "object" && !Array.isArray(obj) && obj !== null && obj !== void 0;
+  };
+  var deepEqual = (objA, objB) => {
+    const lodashIsEqual = (0, import_lodash.default)(objA, objB);
+    if (lodashIsEqual) {
+      return true;
+    }
+    const objAIsObject = isObject(objA);
+    const objBIsObject = isObject(objB);
+    if (!objAIsObject || !objBIsObject) {
+      return lodashIsEqual;
+    }
+    const keysA = Object.keys(objA);
+    const keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length) {
+      return false;
+    }
+    for (let i = 0; i < keysA.length; i++) {
+      if (typeof objA[keysA[i]] === "function" && typeof objB[keysA[i]] === "function") {
+        if (!functionsEqual(objA[keysA[i]], objB[keysA[i]])) {
+          return false;
+        }
+      } else if (!Object.hasOwnProperty.call(objB, keysA[i]) || !(0, import_lodash.default)(objA[keysA[i]], objB[keysA[i]])) {
+        return false;
+      }
+    }
+    return true;
+  };
+  var difference = (objA, objB) => {
+    const diff = [];
+    Object.keys(Object.assign({}, objA, objB)).forEach((key) => {
+      if (typeof objA[key] === "function" && typeof objB[key] === "function") {
+        if (!functionsEqual(objA[key], objB[key])) {
+          diff.push({
+            key,
+            objA: objA[key],
+            objB: objB[key]
+          });
+        }
+      } else if (!Object.is(objA[key], objB[key])) {
+        diff.push({
+          key,
+          objA: objA[key],
+          objB: objB[key]
+        });
+      }
+    });
+    return diff;
+  };
+  var rotateArray = (array, n) => {
+    const rotated = [...array];
+    n = n % array.length;
+    if (n < 0)
+      n = array.length + n;
+    for (let i = 0; i < n; i++) {
+      rotated.unshift(rotated.pop());
+    }
+    return rotated;
+  };
+  var onlyUnique = (value, index, self2) => {
+    return self2.indexOf(value) === index;
+  };
+  var makeEmptyArray = (w, h, value = "") => {
+    var arr = [];
+    for (let i = 0; i < h; i++) {
+      arr[i] = [];
+      for (let j = 0; j < w; j++) {
+        arr[i][j] = value;
+      }
+    }
+    return arr;
+  };
+
+  // src/HelperFns/displayTypeHelpers.ts
+  var isChartType = (type) => CHART_TYPES.includes(type);
+  var isTableType = (type) => TABLE_TYPES.includes(type);
+  var isDisplayTypeValid = (response, displayType, dataLength, pivotDataLength, columns, isDataLimited) => {
+    var _a, _b;
+    const supportedDisplayTypes = getSupportedDisplayTypes({
+      response,
+      columns: columns ?? ((_b = (_a = response == null ? void 0 : response.data) == null ? void 0 : _a.data) == null ? void 0 : _b.columns),
+      dataLength,
+      pivotDataLength,
+      isDataLimited
+    });
+    const isValid = displayType && supportedDisplayTypes.includes(displayType);
+    return isValid;
+  };
+  var shouldPlotMultiSeries = (columns) => {
+    if (isAggregation(columns)) {
+      return false;
+    }
+    const multiSeriesIndex = columns.findIndex((col) => col.multi_series === true);
+    return multiSeriesIndex >= 0;
+  };
+  var supportsPieChart = (columns, chartData) => {
+    if (shouldPlotMultiSeries(columns)) {
+      return false;
+    }
+    if (chartData) {
+      return chartData.length < 7;
+    }
+    return true;
+  };
+  var supports2DCharts = (columns, dataLength) => {
+    if (dataLength <= 1) {
+      return false;
+    }
+    const { amountOfNumberColumns, amountOfStringColumns } = getColumnTypeAmounts(columns);
+    return amountOfNumberColumns > 0 && amountOfStringColumns > 0;
+  };
+  var supportsRegularPivotTable = (columns, dataLength, data) => {
+    var _a, _b;
+    if (dataLength <= 1) {
+      return false;
+    }
+    const groupbyColumns = getGroupableColumns(columns);
+    const hasTwoGroupables = (groupbyColumns == null ? void 0 : groupbyColumns.length) === 2;
+    if (!hasTwoGroupables) {
+      return false;
+    }
+    const visibleColumns = getVisibleColumns(columns);
+    const groupbyColumn1 = columns[groupbyColumns[0]];
+    const groupbyColumn2 = columns[groupbyColumns[1]];
+    if (!groupbyColumn1.is_visible || !groupbyColumn2.is_visible || !((visibleColumns == null ? void 0 : visibleColumns.length) >= 3)) {
+      return false;
+    }
+    const column1Data = (data == null ? void 0 : data.map((row) => {
+      return row[groupbyColumns[0]];
+    })) ?? [];
+    const column2Data = (data == null ? void 0 : data.map((row) => {
+      return row[groupbyColumns[1]];
+    })) ?? [];
+    const uniqueData1Length = ((_a = column1Data == null ? void 0 : column1Data.filter(onlyUnique)) == null ? void 0 : _a.length) ?? 0;
+    const uniqueData2Length = ((_b = column2Data == null ? void 0 : column2Data.filter(onlyUnique)) == null ? void 0 : _b.length) ?? 0;
+    if (uniqueData1Length > MAX_LEGEND_LABELS && uniqueData2Length > MAX_LEGEND_LABELS) {
+      console.debug(
+        `Info: Pivot table will not be supported since there are too many unique fields. The calculated dimensions would be: ${uniqueData1Length} x ${uniqueData2Length}`
+      );
+      return false;
+    }
+    return true;
+  };
+  var supportsDatePivotTable = (columns) => {
+    var _a;
+    const dateColumnIndex = columns.findIndex((col) => col.type === "DATE" || col.type === "DATE_STRING");
+    const dateColumn = columns[dateColumnIndex];
+    return dateColumn && ((_a = dateColumn == null ? void 0 : dateColumn.display_name) == null ? void 0 : _a.toLowerCase().includes("month")) && (columns == null ? void 0 : columns.length) === 2;
+  };
+  var isSingleValueResponse = (response) => {
+    var _a, _b, _c, _d, _e, _f;
+    if (!response) {
+      return false;
+    }
+    const rows = (_b = (_a = response == null ? void 0 : response.data) == null ? void 0 : _a.data) == null ? void 0 : _b.rows;
+    const columns = (_d = (_c = response == null ? void 0 : response.data) == null ? void 0 : _c.data) == null ? void 0 : _d.columns;
+    const referenceID = (_e = response == null ? void 0 : response.data) == null ? void 0 : _e.reference_id;
+    const hasNoData = rows && !(rows == null ? void 0 : rows.length);
+    const hasOneColumn = (columns == null ? void 0 : columns.length) === 1;
+    if (hasNoData && hasOneColumn && referenceID === "1.1.211") {
+      return true;
+    }
+    const oneRowAndColumn = (rows == null ? void 0 : rows.length) === 1 && ((_f = rows[0]) == null ? void 0 : _f.length) === 1;
+    if (oneRowAndColumn) {
+      return true;
+    }
+    return false;
+  };
+  var getSupportedDisplayTypes = ({
+    response,
+    columns,
+    dataLength,
+    pivotDataLength,
+    isDataLimited
+  } = {}) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    try {
+      if (!((_b = (_a = response == null ? void 0 : response.data) == null ? void 0 : _a.data) == null ? void 0 : _b.display_type)) {
+        return [];
+      }
+      const displayType = response.data.data.display_type;
+      if (displayType === "suggestion" || displayType === "help" || displayType === "html") {
+        return [displayType];
+      }
+      const rows = ((_d = (_c = response == null ? void 0 : response.data) == null ? void 0 : _c.data) == null ? void 0 : _d.rows) ?? [];
+      const allColumns = columns || ((_f = (_e = response == null ? void 0 : response.data) == null ? void 0 : _e.data) == null ? void 0 : _f.columns);
+      const visibleColumns = getVisibleColumns(allColumns);
+      if (!(visibleColumns == null ? void 0 : visibleColumns.length)) {
+        return ["text"];
+      }
+      if (isSingleValueResponse(response)) {
+        return ["single-value"];
+      }
+      if (!(rows == null ? void 0 : rows.length)) {
+        return ["table"];
+      }
+      const maxRowsForPieChart = 10;
+      const numRows = dataLength ?? rows.length;
+      let pivotDataHasLength = true;
+      const pivotDataLengthProvided = pivotDataLength !== void 0 && pivotDataLength !== null;
+      if (pivotDataLengthProvided) {
+        pivotDataHasLength = !!pivotDataLength;
+      }
+      if (supportsRegularPivotTable(visibleColumns, numRows, (_h = (_g = response == null ? void 0 : response.data) == null ? void 0 : _g.data) == null ? void 0 : _h.rows)) {
+        const supportedDisplayTypes = ["table"];
+        if (!isDataLimited) {
+          supportedDisplayTypes.push("pivot_table");
+        }
+        if (
+          // Comment out for now so chart row count doesnt change display type
+          // numRows <= maxRowsForPivot &&
+          pivotDataHasLength
+        ) {
+          supportedDisplayTypes.push("stacked_column", "stacked_bar", "column", "bar", "bubble", "heatmap");
+          if (hasDateColumn(visibleColumns)) {
+            supportedDisplayTypes.push("stacked_line", "line");
+          }
+        }
+        return supportedDisplayTypes;
+      } else if (supports2DCharts(visibleColumns, numRows)) {
+        const supportedDisplayTypes = ["table", "column", "bar"];
+        if (numRows > MIN_HISTOGRAM_SAMPLE) {
+          supportedDisplayTypes.push("histogram");
+        }
+        if (hasDateColumn(visibleColumns)) {
+          supportedDisplayTypes.push("line");
+        }
+        if (numRows > 1 && numRows <= maxRowsForPieChart) {
+          supportedDisplayTypes.push("pie");
+        }
+        const { amountOfNumberColumns } = getColumnTypeAmounts(visibleColumns);
+        if (amountOfNumberColumns > 1) {
+          supportedDisplayTypes.push("column_line");
+          supportedDisplayTypes.push("scatterplot");
+        }
+        if (!isDataLimited && supportsDatePivotTable(visibleColumns)) {
+          const dateColumnIndex = visibleColumns.findIndex((col) => col.type === "DATE" || col.type === "DATE_STRING");
+          const dateColumn = visibleColumns[dateColumnIndex];
+          const data = (_j = (_i = response == null ? void 0 : response.data) == null ? void 0 : _i.data) == null ? void 0 : _j.rows;
+          const uniqueYears = [];
+          data.forEach((row) => {
+            const year = formatElement({
+              element: row[dateColumnIndex],
+              column: dateColumn,
+              config: getDataFormatting({ monthYearFormat: "YYYY", dayMonthYearFormat: "YYYY" })
+            });
+            if (!uniqueYears.includes(year)) {
+              uniqueYears.push(year);
+            }
+          });
+          if (uniqueYears.length > 1) {
+            supportedDisplayTypes.push("pivot_table");
+          }
+        }
+        return supportedDisplayTypes;
+      }
+      return ["table"];
+    } catch (error) {
+      console.error(error);
+      return ["table"];
+    }
+  };
+  var getFirstChartDisplayType = (supportedDisplayTypes, fallback) => {
+    const chartType = supportedDisplayTypes.find((displayType) => isChartType(displayType));
+    if (chartType) {
+      return chartType;
+    }
+    return fallback;
+  };
+  var getDefaultDisplayType = (response, defaultToChart, columns, dataLength, pivotDataLength, preferredDisplayType, isDataLimited = false) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const supportedDisplayTypes = getSupportedDisplayTypes({
+      response,
+      columns: columns ?? ((_b = (_a = response == null ? void 0 : response.data) == null ? void 0 : _a.data) == null ? void 0 : _b.columns),
+      dataLength,
+      pivotDataLength,
+      isDataLimited
+    });
+    if (preferredDisplayType && supportedDisplayTypes.includes(preferredDisplayType)) {
+      return preferredDisplayType;
+    }
+    const responseDisplayType = (_d = (_c = response == null ? void 0 : response.data) == null ? void 0 : _c.data) == null ? void 0 : _d.display_type;
+    if (supportedDisplayTypes.includes(preferredDisplayType)) {
+      return preferredDisplayType;
+    }
+    if (responseDisplayType === "suggestion" || responseDisplayType === "help" || responseDisplayType === "html") {
+      return responseDisplayType;
+    }
+    if (supportedDisplayTypes.length === 1) {
+      return supportedDisplayTypes[0];
+    }
+    if (supportedDisplayTypes.includes("pivot_table")) {
+      let displayType = "pivot_table";
+      if (defaultToChart) {
+        displayType = isAggregation((_f = (_e = response == null ? void 0 : response.data) == null ? void 0 : _e.data) == null ? void 0 : _f.columns) ? getFirstChartDisplayType(supportedDisplayTypes, "pivot_table") : "pivot_table";
+      }
+      return displayType;
+    }
+    if (!responseDisplayType && hasData(response) || responseDisplayType === "data") {
+      let displayType = "table";
+      if (defaultToChart) {
+        displayType = isAggregation((_h = (_g = response == null ? void 0 : response.data) == null ? void 0 : _g.data) == null ? void 0 : _h.columns) ? getFirstChartDisplayType(supportedDisplayTypes, "table") : "table";
+      }
+      return displayType;
+    }
+    return "text";
+  };
+  var hasData = (response) => {
+    var _a, _b, _c;
+    if (!response) {
+      return false;
+    }
+    return (_c = (_b = (_a = response == null ? void 0 : response.data) == null ? void 0 : _a.data) == null ? void 0 : _b.rows) == null ? void 0 : _c.length;
+  };
+
+  // src/HelperFns/domHelpers.ts
+  var currentEventLoopEnd = () => {
+    return new Promise((resolve) => {
+      setTimeout(resolve, 0);
+    });
+  };
+  var animateInputText = ({ text = "", inputRef, callback = () => {
+  }, totalAnimationTime = 1e3 }) => {
+    if (!text.length || !inputRef || typeof text !== "string") {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      const timePerChar = Math.round(totalAnimationTime / text.length);
+      for (let i = 1; i <= text.length; i++) {
+        setTimeout(() => {
+          inputRef.value = text.slice(0, i);
+          if (i === text.length) {
+            setTimeout(() => {
+              callback();
+              resolve();
+            }, 300);
+          }
+        }, i * timePerChar);
+      }
+    });
+  };
+  var handleTooltipBoundaryCollision = (e, self2) => {
+    var _a;
+    const tooltipRef = (_a = self2 == null ? void 0 : self2.reactTooltipRef) == null ? void 0 : _a.tooltipRef;
+    if (!tooltipRef) {
+      return;
+    }
+    const rect = tooltipRef.getBoundingClientRect();
+    const overflownLeft = rect.left < 0;
+    const overflownRight = rect.right > window.innerWidth;
+    if (overflownLeft) {
+      tooltipRef.style.setProperty("left", "10px");
+      tooltipRef.style.setProperty("right", "auto");
+    } else if (overflownRight) {
+      tooltipRef.style.setProperty("left", "auto");
+      tooltipRef.style.setProperty("right", "10px");
+    }
+  };
+  var removeFromDOM = (elem) => {
+    if (!elem) {
+      return;
+    }
+    try {
+      if (typeof elem.forEach === "function" && (elem == null ? void 0 : elem.length)) {
+        elem.forEach((el) => {
+          if (el && typeof el.remove === "function") {
+            el.remove();
+          }
+        });
+      } else if (typeof elem.remove === "function") {
+        elem.remove();
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  };
+  var setCaretPosition = (elem, caretPos) => {
+    if (elem !== null) {
+      if (elem.createTextRange) {
+        const range = elem.createTextRange();
+        range.move("character", caretPos);
+        range.select();
+      } else {
+        if (elem.selectionStart) {
+          elem.focus();
+          elem.setSelectionRange(caretPos, caretPos);
+        } else {
+          elem.focus();
+        }
+      }
+    }
+  };
+  var getPadding = (element) => {
+    const padding = { left: 0, right: 0, top: 0, bottom: 0 };
+    try {
+      const left = parseInt(window.getComputedStyle(element)["padding-left"], 10);
+      const right = parseInt(window.getComputedStyle(element)["padding-right"], 10);
+      const top = parseInt(window.getComputedStyle(element)["padding-top"], 10);
+      const bottom = parseInt(window.getComputedStyle(element)["padding-bottom"], 10);
+      padding.left = left;
+      padding.right = right;
+      padding.top = top;
+      padding.bottom = bottom;
+    } catch (error) {
+      return padding;
+    }
+    return padding;
+  };
+  var getQueryParams = (url) => {
+    try {
+      const queryParams = {};
+      const anchor = document.createElement("a");
+      anchor.href = url;
+      const queryStrings = anchor.search.substring(1);
+      const params = queryStrings.split("&");
+      for (var i = 0; i < params.length; i++) {
+        var pair = params[i].split("=");
+        queryParams[pair[0]] = decodeURIComponent(pair[1]);
+      }
+      return queryParams;
+    } catch (error) {
+      return void 0;
+    }
+  };
+  var svgToPng = (svgElement, scale = 3) => {
+    return new Promise(function(resolve, reject) {
+      try {
+        const bbox = svgElement.getBoundingClientRect();
+        const originalWidth = bbox.width;
+        const originalHeight = bbox.height;
+        const scaledWidth = originalWidth * scale;
+        const scaledHeight = originalHeight * scale;
+        const clonedSvg = svgElement.cloneNode(true);
+        clonedSvg.setAttribute("transform-origin", "top left");
+        clonedSvg.setAttribute("transform", `scale(${scale})`);
+        const image64 = getSVGBase64(clonedSvg);
+        const canvas = document.createElement("canvas");
+        canvas.style.width = originalWidth + "px";
+        canvas.style.height = originalHeight + "px";
+        canvas.width = scaledWidth;
+        canvas.height = scaledHeight;
+        const ctx = canvas.getContext("2d");
+        const img = new Image();
+        img.onload = function() {
+          ctx.drawImage(this, 0, 0, scaledWidth, scaledHeight);
+          resolve(canvas.toDataURL("image/png", 1));
+        };
+        img.onerror = function() {
+          reject("failed to load image");
+        };
+        img.src = image64;
+      } catch (error) {
+        console.error(error);
+        reject("failed to convert svg to png " + error);
+      }
+    });
+  };
+  var getBBoxFromRef = (ref) => {
+    if (!ref || !ref.getBBox) {
+      return;
+    }
+    return ref.getBBox();
+  };
+  var getSVGBase64 = (svgElement) => {
+    try {
+      const domUrl = window.URL || window.webkitURL || window;
+      if (!domUrl) {
+        throw new Error("(browser doesnt support this)");
+      } else if (!svgElement) {
+        throw new Error("(svg element does not exist)");
+      }
+      var xml = new XMLSerializer().serializeToString(svgElement);
+      var svg64 = btoa(unescape(encodeURIComponent(xml)));
+      const imgSrc = `data:image/svg+xml;base64,${svg64}`;
+      return imgSrc;
+    } catch (error) {
+      return void 0;
+    }
+  };
+
+  // src/HelperFns/propsHelpers.ts
+  var getStringFromSource = (source) => {
+    if (typeof source === "string" || typeof source === "number") {
+      return `${source}`;
+    }
+    if (Array.isArray(source) && !!source.length) {
+      return source.join(".");
+    }
+    return null;
+  };
+  var mergeSources = (source, newSource) => {
+    let finalSource = null;
+    try {
+      const sourceString = getStringFromSource(source);
+      const newSourceString = getStringFromSource(newSource);
+      if (sourceString && newSourceString) {
+        finalSource = [sourceString, newSourceString].join(".");
+      } else if (sourceString) {
+        finalSource = sourceString;
+      } else if (newSourceString) {
+        finalSource = newSourceString;
+      }
+    } catch (error) {
+      console.error(error);
+    }
+    return finalSource;
+  };
+})();
+//# sourceMappingURL=index.global.js.map