hplx-feature-library 1.0.172 → 1.0.173

package/dist/APIAction--DyoXs57.js

@@ -0,0 +1,3752 @@
+import { d as I } from "./dayjs.min-BbV4duaj.js";
+var Ee, Ie;
+function Lt() {
+  if (Ie) return Ee;
+  Ie = 1;
+  function t(d) {
+    this._maxSize = d, this.clear();
+  }
+  t.prototype.clear = function() {
+    this._size = 0, this._values = /* @__PURE__ */ Object.create(null);
+  }, t.prototype.get = function(d) {
+    return this._values[d];
+  }, t.prototype.set = function(d, b) {
+    return this._size >= this._maxSize && this.clear(), d in this._values || this._size++, this._values[d] = b;
+  };
+  var e = /[^.^\]^[]+|(?=\[\]|\.\.)/g, r = /^\d+$/, n = /^\d/, s = /[~`!#$%\^&*+=\-\[\]\\';,/{}|\\":<>\?]/g, i = /^\s*(['"]?)(.*?)(\1)\s*$/, a = 512, o = new t(a), u = new t(a), c = new t(a);
+  Ee = {
+    Cache: t,
+    split: h,
+    normalizePath: f,
+    setter: function(d) {
+      var b = f(d);
+      return u.get(d) || u.set(d, function(O, T) {
+        for (var v = 0, x = b.length, C = O; v < x - 1; ) {
+          var k = b[v];
+          if (k === "__proto__" || k === "constructor" || k === "prototype")
+            return O;
+          C = C[b[v++]];
+        }
+        C[b[v]] = T;
+      });
+    },
+    getter: function(d, b) {
+      var E = f(d);
+      return c.get(d) || c.set(d, function(T) {
+        for (var v = 0, x = E.length; v < x; )
+          if (T != null || !b) T = T[E[v++]];
+          else return;
+        return T;
+      });
+    },
+    join: function(d) {
+      return d.reduce(function(b, E) {
+        return b + (w(E) || r.test(E) ? "[" + E + "]" : (b ? "." : "") + E);
+      }, "");
+    },
+    forEach: function(d, b, E) {
+      y(Array.isArray(d) ? d : h(d), b, E);
+    }
+  };
+  function f(d) {
+    return o.get(d) || o.set(
+      d,
+      h(d).map(function(b) {
+        return b.replace(i, "$2");
+      })
+    );
+  }
+  function h(d) {
+    return d.match(e) || [""];
+  }
+  function y(d, b, E) {
+    var O = d.length, T, v, x, C;
+    for (v = 0; v < O; v++)
+      T = d[v], T && (m(T) && (T = '"' + T + '"'), C = w(T), x = !C && /^\d+$/.test(T), b.call(E, T, C, x, v, d));
+  }
+  function w(d) {
+    return typeof d == "string" && d && ["'", '"'].indexOf(d.charAt(0)) !== -1;
+  }
+  function p(d) {
+    return d.match(n) && !d.match(r);
+  }
+  function g(d) {
+    return s.test(d);
+  }
+  function m(d) {
+    return !w(d) && (p(d) || g(d));
+  }
+  return Ee;
+}
+var rt = Lt(), ae = { exports: {} }, Le;
+function Ut() {
+  if (Le) return ae.exports;
+  Le = 1, ae.exports = function(s) {
+    return t(e(s), s);
+  }, ae.exports.array = t;
+  function t(s, i) {
+    var a = s.length, o = new Array(a), u = {}, c = a, f = r(i), h = n(s);
+    for (i.forEach(function(w) {
+      if (!h.has(w[0]) || !h.has(w[1]))
+        throw new Error("Unknown node. There is an unknown node in the supplied edges.");
+    }); c--; )
+      u[c] || y(s[c], c, /* @__PURE__ */ new Set());
+    return o;
+    function y(w, p, g) {
+      if (g.has(w)) {
+        var m;
+        try {
+          m = ", node was:" + JSON.stringify(w);
+        } catch {
+          m = "";
+        }
+        throw new Error("Cyclic dependency" + m);
+      }
+      if (!h.has(w))
+        throw new Error("Found unknown node. Make sure to provided all involved nodes. Unknown node: " + JSON.stringify(w));
+      if (!u[p]) {
+        u[p] = !0;
+        var d = f.get(w) || /* @__PURE__ */ new Set();
+        if (d = Array.from(d), p = d.length) {
+          g.add(w);
+          do {
+            var b = d[--p];
+            y(b, h.get(b), g);
+          } while (p);
+          g.delete(w);
+        }
+        o[--a] = w;
+      }
+    }
+  }
+  function e(s) {
+    for (var i = /* @__PURE__ */ new Set(), a = 0, o = s.length; a < o; a++) {
+      var u = s[a];
+      i.add(u[0]), i.add(u[1]);
+    }
+    return Array.from(i);
+  }
+  function r(s) {
+    for (var i = /* @__PURE__ */ new Map(), a = 0, o = s.length; a < o; a++) {
+      var u = s[a];
+      i.has(u[0]) || i.set(u[0], /* @__PURE__ */ new Set()), i.has(u[1]) || i.set(u[1], /* @__PURE__ */ new Set()), i.get(u[0]).add(u[1]);
+    }
+    return i;
+  }
+  function n(s) {
+    for (var i = /* @__PURE__ */ new Map(), a = 0, o = s.length; a < o; a++)
+      i.set(s[a], a);
+    return i;
+  }
+  return ae.exports;
+}
+Ut();
+const qt = Object.prototype.toString, zt = Error.prototype.toString, Ht = RegExp.prototype.toString, Vt = typeof Symbol < "u" ? Symbol.prototype.toString : () => "", Gt = /^Symbol\((.*)\)(.*)$/;
+function Jt(t) {
+  return t != +t ? "NaN" : t === 0 && 1 / t < 0 ? "-0" : "" + t;
+}
+function Ue(t, e = !1) {
+  if (t == null || t === !0 || t === !1) return "" + t;
+  const r = typeof t;
+  if (r === "number") return Jt(t);
+  if (r === "string") return e ? `"${t}"` : t;
+  if (r === "function") return "[Function " + (t.name || "anonymous") + "]";
+  if (r === "symbol") return Vt.call(t).replace(Gt, "Symbol($1)");
+  const n = qt.call(t).slice(8, -1);
+  return n === "Date" ? isNaN(t.getTime()) ? "" + t : t.toISOString(t) : n === "Error" || t instanceof Error ? "[" + zt.call(t) + "]" : n === "RegExp" ? Ht.call(t) : null;
+}
+function L(t, e) {
+  let r = Ue(t, e);
+  return r !== null ? r : JSON.stringify(t, function(n, s) {
+    let i = Ue(this[n], e);
+    return i !== null ? i : s;
+  }, 2);
+}
+function nt(t) {
+  return t == null ? [] : [].concat(t);
+}
+let st, it, at, Kt = /\$\{\s*(\w+)\s*\}/g;
+st = Symbol.toStringTag;
+class qe {
+  constructor(e, r, n, s) {
+    this.name = void 0, this.message = void 0, this.value = void 0, this.path = void 0, this.type = void 0, this.params = void 0, this.errors = void 0, this.inner = void 0, this[st] = "Error", this.name = "ValidationError", this.value = r, this.path = n, this.type = s, this.errors = [], this.inner = [], nt(e).forEach((i) => {
+      if (D.isError(i)) {
+        this.errors.push(...i.errors);
+        const a = i.inner.length ? i.inner : [i];
+        this.inner.push(...a);
+      } else
+        this.errors.push(i);
+    }), this.message = this.errors.length > 1 ? `${this.errors.length} errors occurred` : this.errors[0];
+  }
+}
+it = Symbol.hasInstance;
+at = Symbol.toStringTag;
+class D extends Error {
+  static formatError(e, r) {
+    const n = r.label || r.path || "this";
+    return r = Object.assign({}, r, {
+      path: n,
+      originalPath: r.path
+    }), typeof e == "string" ? e.replace(Kt, (s, i) => L(r[i])) : typeof e == "function" ? e(r) : e;
+  }
+  static isError(e) {
+    return e && e.name === "ValidationError";
+  }
+  constructor(e, r, n, s, i) {
+    const a = new qe(e, r, n, s);
+    if (i)
+      return a;
+    super(), this.value = void 0, this.path = void 0, this.type = void 0, this.params = void 0, this.errors = [], this.inner = [], this[at] = "Error", this.name = a.name, this.message = a.message, this.type = a.type, this.value = a.value, this.path = a.path, this.errors = a.errors, this.inner = a.inner, Error.captureStackTrace && Error.captureStackTrace(this, D);
+  }
+  static [it](e) {
+    return qe[Symbol.hasInstance](e) || super[Symbol.hasInstance](e);
+  }
+}
+let M = {
+  default: "${path} is invalid",
+  required: "${path} is a required field",
+  defined: "${path} must be defined",
+  notNull: "${path} cannot be null",
+  oneOf: "${path} must be one of the following values: ${values}",
+  notOneOf: "${path} must not be one of the following values: ${values}",
+  notType: ({
+    path: t,
+    type: e,
+    value: r,
+    originalValue: n
+  }) => {
+    const s = n != null && n !== r ? ` (cast from the value \`${L(n, !0)}\`).` : ".";
+    return e !== "mixed" ? `${t} must be a \`${e}\` type, but the final value was: \`${L(r, !0)}\`` + s : `${t} must match the configured type. The validated value was: \`${L(r, !0)}\`` + s;
+  }
+}, _ = {
+  length: "${path} must be exactly ${length} characters",
+  min: "${path} must be at least ${min} characters",
+  max: "${path} must be at most ${max} characters",
+  matches: '${path} must match the following: "${regex}"',
+  email: "${path} must be a valid email",
+  url: "${path} must be a valid URL",
+  uuid: "${path} must be a valid UUID",
+  datetime: "${path} must be a valid ISO date-time",
+  datetime_precision: "${path} must be a valid ISO date-time with a sub-second precision of exactly ${precision} digits",
+  datetime_offset: '${path} must be a valid ISO date-time with UTC "Z" timezone',
+  trim: "${path} must be a trimmed string",
+  lowercase: "${path} must be a lowercase string",
+  uppercase: "${path} must be a upper case string"
+}, Yt = {
+  min: "${path} must be greater than or equal to ${min}",
+  max: "${path} must be less than or equal to ${max}",
+  lessThan: "${path} must be less than ${less}",
+  moreThan: "${path} must be greater than ${more}",
+  positive: "${path} must be a positive number",
+  negative: "${path} must be a negative number",
+  integer: "${path} must be an integer"
+}, Oe = {
+  min: "${path} field must be later than ${min}",
+  max: "${path} field must be at earlier than ${max}"
+}, Wt = {
+  isValue: "${path} field must be ${value}"
+}, Xt = {
+  noUnknown: "${path} field has unspecified keys: ${unknown}",
+  exact: "${path} object contains unknown properties: ${properties}"
+}, Zt = {
+  min: "${path} field must have at least ${min} items",
+  max: "${path} field must have less than or equal to ${max} items",
+  length: "${path} must have ${length} items"
+}, Qt = {
+  notType: (t) => {
+    const {
+      path: e,
+      value: r,
+      spec: n
+    } = t, s = n.types.length;
+    if (Array.isArray(r)) {
+      if (r.length < s) return `${e} tuple value has too few items, expected a length of ${s} but got ${r.length} for value: \`${L(r, !0)}\``;
+      if (r.length > s) return `${e} tuple value has too many items, expected a length of ${s} but got ${r.length} for value: \`${L(r, !0)}\``;
+    }
+    return D.formatError(M.notType, t);
+  }
+};
+Object.assign(/* @__PURE__ */ Object.create(null), {
+  mixed: M,
+  string: _,
+  number: Yt,
+  date: Oe,
+  object: Xt,
+  array: Zt,
+  boolean: Wt,
+  tuple: Qt
+});
+const ot = (t) => t && t.__isYupSchema__;
+class fe {
+  static fromOptions(e, r) {
+    if (!r.then && !r.otherwise) throw new TypeError("either `then:` or `otherwise:` is required for `when()` conditions");
+    let {
+      is: n,
+      then: s,
+      otherwise: i
+    } = r, a = typeof n == "function" ? n : (...o) => o.every((u) => u === n);
+    return new fe(e, (o, u) => {
+      var c;
+      let f = a(...o) ? s : i;
+      return (c = f?.(u)) != null ? c : u;
+    });
+  }
+  constructor(e, r) {
+    this.fn = void 0, this.refs = e, this.refs = e, this.fn = r;
+  }
+  resolve(e, r) {
+    let n = this.refs.map((i) => (
+      // TODO: ? operator here?
+      i.getValue(r?.value, r?.parent, r?.context)
+    )), s = this.fn(n, e, r);
+    if (s === void 0 || // @ts-ignore this can be base
+    s === e)
+      return e;
+    if (!ot(s)) throw new TypeError("conditions must return a schema object");
+    return s.resolve(r);
+  }
+}
+const oe = {
+  context: "$",
+  value: "."
+};
+class Q {
+  constructor(e, r = {}) {
+    if (this.key = void 0, this.isContext = void 0, this.isValue = void 0, this.isSibling = void 0, this.path = void 0, this.getter = void 0, this.map = void 0, typeof e != "string") throw new TypeError("ref must be a string, got: " + e);
+    if (this.key = e.trim(), e === "") throw new TypeError("ref must be a non-empty string");
+    this.isContext = this.key[0] === oe.context, this.isValue = this.key[0] === oe.value, this.isSibling = !this.isContext && !this.isValue;
+    let n = this.isContext ? oe.context : this.isValue ? oe.value : "";
+    this.path = this.key.slice(n.length), this.getter = this.path && rt.getter(this.path, !0), this.map = r.map;
+  }
+  getValue(e, r, n) {
+    let s = this.isContext ? n : this.isValue ? e : r;
+    return this.getter && (s = this.getter(s || {})), this.map && (s = this.map(s)), s;
+  }
+  /**
+   *
+   * @param {*} value
+   * @param {Object} options
+   * @param {Object=} options.context
+   * @param {Object=} options.parent
+   */
+  cast(e, r) {
+    return this.getValue(e, r?.parent, r?.context);
+  }
+  resolve() {
+    return this;
+  }
+  describe() {
+    return {
+      type: "ref",
+      key: this.key
+    };
+  }
+  toString() {
+    return `Ref(${this.key})`;
+  }
+  static isRef(e) {
+    return e && e.__isYupRef;
+  }
+}
+Q.prototype.__isYupRef = !0;
+const q = (t) => t == null;
+function G(t) {
+  function e({
+    value: r,
+    path: n = "",
+    options: s,
+    originalValue: i,
+    schema: a
+  }, o, u) {
+    const {
+      name: c,
+      test: f,
+      params: h,
+      message: y,
+      skipAbsent: w
+    } = t;
+    let {
+      parent: p,
+      context: g,
+      abortEarly: m = a.spec.abortEarly,
+      disableStackTrace: d = a.spec.disableStackTrace
+    } = s;
+    const b = {
+      value: r,
+      parent: p,
+      context: g
+    };
+    function E(R = {}) {
+      const ie = lt(Object.assign({
+        value: r,
+        originalValue: i,
+        label: a.spec.label,
+        path: R.path || n,
+        spec: a.spec,
+        disableStackTrace: R.disableStackTrace || d
+      }, h, R.params), b), je = new D(D.formatError(R.message || y, ie), r, ie.path, R.type || c, ie.disableStackTrace);
+      return je.params = ie, je;
+    }
+    const O = m ? o : u;
+    let T = {
+      path: n,
+      parent: p,
+      type: c,
+      from: s.from,
+      createError: E,
+      resolve(R) {
+        return ut(R, b);
+      },
+      options: s,
+      originalValue: i,
+      schema: a
+    };
+    const v = (R) => {
+      D.isError(R) ? O(R) : R ? u(null) : O(E());
+    }, x = (R) => {
+      D.isError(R) ? O(R) : o(R);
+    };
+    if (w && q(r))
+      return v(!0);
+    let k;
+    try {
+      var Me;
+      if (k = f.call(T, r, T), typeof ((Me = k) == null ? void 0 : Me.then) == "function") {
+        if (s.sync)
+          throw new Error(`Validation test of type: "${T.type}" returned a Promise during a synchronous validate. This test will finish after the validate call has returned`);
+        return Promise.resolve(k).then(v, x);
+      }
+    } catch (R) {
+      x(R);
+      return;
+    }
+    v(k);
+  }
+  return e.OPTIONS = t, e;
+}
+function lt(t, e) {
+  if (!t) return t;
+  for (const r of Object.keys(t))
+    t[r] = ut(t[r], e);
+  return t;
+}
+function ut(t, e) {
+  return Q.isRef(t) ? t.getValue(e.value, e.parent, e.context) : t;
+}
+function er(t, e, r, n = r) {
+  let s, i, a;
+  return e ? (rt.forEach(e, (o, u, c) => {
+    let f = u ? o.slice(1, o.length - 1) : o;
+    t = t.resolve({
+      context: n,
+      parent: s,
+      value: r
+    });
+    let h = t.type === "tuple", y = c ? parseInt(f, 10) : 0;
+    if (t.innerType || h) {
+      if (h && !c) throw new Error(`Yup.reach cannot implicitly index into a tuple type. the path part "${a}" must contain an index to the tuple element, e.g. "${a}[0]"`);
+      if (r && y >= r.length)
+        throw new Error(`Yup.reach cannot resolve an array item at index: ${o}, in the path: ${e}. because there is no value at that index. `);
+      s = r, r = r && r[y], t = h ? t.spec.types[y] : t.innerType;
+    }
+    if (!c) {
+      if (!t.fields || !t.fields[f]) throw new Error(`The schema does not contain the path: ${e}. (failed at: ${a} which is a type: "${t.type}")`);
+      s = r, r = r && r[f], t = t.fields[f];
+    }
+    i = f, a = u ? "[" + o + "]" : "." + o;
+  }), {
+    schema: t,
+    parent: s,
+    parentPath: i
+  }) : {
+    parent: s,
+    parentPath: e,
+    schema: t
+  };
+}
+class he extends Set {
+  describe() {
+    const e = [];
+    for (const r of this.values())
+      e.push(Q.isRef(r) ? r.describe() : r);
+    return e;
+  }
+  resolveAll(e) {
+    let r = [];
+    for (const n of this.values())
+      r.push(e(n));
+    return r;
+  }
+  clone() {
+    return new he(this.values());
+  }
+  merge(e, r) {
+    const n = this.clone();
+    return e.forEach((s) => n.add(s)), r.forEach((s) => n.delete(s)), n;
+  }
+}
+function J(t, e = /* @__PURE__ */ new Map()) {
+  if (ot(t) || !t || typeof t != "object") return t;
+  if (e.has(t)) return e.get(t);
+  let r;
+  if (t instanceof Date)
+    r = new Date(t.getTime()), e.set(t, r);
+  else if (t instanceof RegExp)
+    r = new RegExp(t), e.set(t, r);
+  else if (Array.isArray(t)) {
+    r = new Array(t.length), e.set(t, r);
+    for (let n = 0; n < t.length; n++) r[n] = J(t[n], e);
+  } else if (t instanceof Map) {
+    r = /* @__PURE__ */ new Map(), e.set(t, r);
+    for (const [n, s] of t.entries()) r.set(n, J(s, e));
+  } else if (t instanceof Set) {
+    r = /* @__PURE__ */ new Set(), e.set(t, r);
+    for (const n of t) r.add(J(n, e));
+  } else if (t instanceof Object) {
+    r = {}, e.set(t, r);
+    for (const [n, s] of Object.entries(t)) r[n] = J(s, e);
+  } else
+    throw Error(`Unable to clone ${t}`);
+  return r;
+}
+function tr(t) {
+  if (!(t != null && t.length))
+    return;
+  const e = [];
+  let r = "", n = !1, s = !1;
+  for (let i = 0; i < t.length; i++) {
+    const a = t[i];
+    if (a === "[" && !s) {
+      r && (e.push(...r.split(".").filter(Boolean)), r = ""), n = !0;
+      continue;
+    }
+    if (a === "]" && !s) {
+      r && (/^\d+$/.test(r) ? e.push(r) : e.push(r.replace(/^"|"$/g, "")), r = ""), n = !1;
+      continue;
+    }
+    if (a === '"') {
+      s = !s;
+      continue;
+    }
+    if (a === "." && !n && !s) {
+      r && (e.push(r), r = "");
+      continue;
+    }
+    r += a;
+  }
+  return r && e.push(...r.split(".").filter(Boolean)), e;
+}
+function rr(t, e) {
+  const r = e ? `${e}.${t.path}` : t.path;
+  return t.errors.map((n) => ({
+    message: n,
+    path: tr(r)
+  }));
+}
+function ct(t, e) {
+  var r;
+  if (!((r = t.inner) != null && r.length) && t.errors.length)
+    return rr(t, e);
+  const n = e ? `${e}.${t.path}` : t.path;
+  return t.inner.flatMap((s) => ct(s, n));
+}
+class U {
+  constructor(e) {
+    this.type = void 0, this.deps = [], this.tests = void 0, this.transforms = void 0, this.conditions = [], this._mutate = void 0, this.internalTests = {}, this._whitelist = new he(), this._blacklist = new he(), this.exclusiveTests = /* @__PURE__ */ Object.create(null), this._typeCheck = void 0, this.spec = void 0, this.tests = [], this.transforms = [], this.withMutation(() => {
+      this.typeError(M.notType);
+    }), this.type = e.type, this._typeCheck = e.check, this.spec = Object.assign({
+      strip: !1,
+      strict: !1,
+      abortEarly: !0,
+      recursive: !0,
+      disableStackTrace: !1,
+      nullable: !1,
+      optional: !0,
+      coerce: !0
+    }, e?.spec), this.withMutation((r) => {
+      r.nonNullable();
+    });
+  }
+  // TODO: remove
+  get _type() {
+    return this.type;
+  }
+  clone(e) {
+    if (this._mutate)
+      return e && Object.assign(this.spec, e), this;
+    const r = Object.create(Object.getPrototypeOf(this));
+    return r.type = this.type, r._typeCheck = this._typeCheck, r._whitelist = this._whitelist.clone(), r._blacklist = this._blacklist.clone(), r.internalTests = Object.assign({}, this.internalTests), r.exclusiveTests = Object.assign({}, this.exclusiveTests), r.deps = [...this.deps], r.conditions = [...this.conditions], r.tests = [...this.tests], r.transforms = [...this.transforms], r.spec = J(Object.assign({}, this.spec, e)), r;
+  }
+  label(e) {
+    let r = this.clone();
+    return r.spec.label = e, r;
+  }
+  meta(...e) {
+    if (e.length === 0) return this.spec.meta;
+    let r = this.clone();
+    return r.spec.meta = Object.assign(r.spec.meta || {}, e[0]), r;
+  }
+  withMutation(e) {
+    let r = this._mutate;
+    this._mutate = !0;
+    let n = e(this);
+    return this._mutate = r, n;
+  }
+  concat(e) {
+    if (!e || e === this) return this;
+    if (e.type !== this.type && this.type !== "mixed") throw new TypeError(`You cannot \`concat()\` schema's of different types: ${this.type} and ${e.type}`);
+    let r = this, n = e.clone();
+    const s = Object.assign({}, r.spec, n.spec);
+    return n.spec = s, n.internalTests = Object.assign({}, r.internalTests, n.internalTests), n._whitelist = r._whitelist.merge(e._whitelist, e._blacklist), n._blacklist = r._blacklist.merge(e._blacklist, e._whitelist), n.tests = r.tests, n.exclusiveTests = r.exclusiveTests, n.withMutation((i) => {
+      e.tests.forEach((a) => {
+        i.test(a.OPTIONS);
+      });
+    }), n.transforms = [...r.transforms, ...n.transforms], n;
+  }
+  isType(e) {
+    return e == null ? !!(this.spec.nullable && e === null || this.spec.optional && e === void 0) : this._typeCheck(e);
+  }
+  resolve(e) {
+    let r = this;
+    if (r.conditions.length) {
+      let n = r.conditions;
+      r = r.clone(), r.conditions = [], r = n.reduce((s, i) => i.resolve(s, e), r), r = r.resolve(e);
+    }
+    return r;
+  }
+  resolveOptions(e) {
+    var r, n, s, i;
+    return Object.assign({}, e, {
+      from: e.from || [],
+      strict: (r = e.strict) != null ? r : this.spec.strict,
+      abortEarly: (n = e.abortEarly) != null ? n : this.spec.abortEarly,
+      recursive: (s = e.recursive) != null ? s : this.spec.recursive,
+      disableStackTrace: (i = e.disableStackTrace) != null ? i : this.spec.disableStackTrace
+    });
+  }
+  /**
+   * Run the configured transform pipeline over an input value.
+   */
+  cast(e, r = {}) {
+    let n = this.resolve(Object.assign({}, r, {
+      value: e
+      // parent: options.parent,
+      // context: options.context,
+    })), s = r.assert === "ignore-optionality", i = n._cast(e, r);
+    if (r.assert !== !1 && !n.isType(i)) {
+      if (s && q(i))
+        return i;
+      let a = L(e), o = L(i);
+      throw new TypeError(`The value of ${r.path || "field"} could not be cast to a value that satisfies the schema type: "${n.type}". 
+
+attempted value: ${a} 
+` + (o !== a ? `result of cast: ${o}` : ""));
+    }
+    return i;
+  }
+  _cast(e, r) {
+    let n = e === void 0 ? e : this.transforms.reduce((s, i) => i.call(this, s, e, this, r), e);
+    return n === void 0 && (n = this.getDefault(r)), n;
+  }
+  _validate(e, r = {}, n, s) {
+    let {
+      path: i,
+      originalValue: a = e,
+      strict: o = this.spec.strict
+    } = r, u = e;
+    o || (u = this._cast(u, Object.assign({
+      assert: !1
+    }, r)));
+    let c = [];
+    for (let f of Object.values(this.internalTests))
+      f && c.push(f);
+    this.runTests({
+      path: i,
+      value: u,
+      originalValue: a,
+      options: r,
+      tests: c
+    }, n, (f) => {
+      if (f.length)
+        return s(f, u);
+      this.runTests({
+        path: i,
+        value: u,
+        originalValue: a,
+        options: r,
+        tests: this.tests
+      }, n, s);
+    });
+  }
+  /**
+   * Executes a set of validations, either schema, produced Tests or a nested
+   * schema validate result.
+   */
+  runTests(e, r, n) {
+    let s = !1, {
+      tests: i,
+      value: a,
+      originalValue: o,
+      path: u,
+      options: c
+    } = e, f = (g) => {
+      s || (s = !0, r(g, a));
+    }, h = (g) => {
+      s || (s = !0, n(g, a));
+    }, y = i.length, w = [];
+    if (!y) return h([]);
+    let p = {
+      value: a,
+      originalValue: o,
+      path: u,
+      options: c,
+      schema: this
+    };
+    for (let g = 0; g < i.length; g++) {
+      const m = i[g];
+      m(p, f, function(b) {
+        b && (Array.isArray(b) ? w.push(...b) : w.push(b)), --y <= 0 && h(w);
+      });
+    }
+  }
+  asNestedTest({
+    key: e,
+    index: r,
+    parent: n,
+    parentPath: s,
+    originalParent: i,
+    options: a
+  }) {
+    const o = e ?? r;
+    if (o == null)
+      throw TypeError("Must include `key` or `index` for nested validations");
+    const u = typeof o == "number";
+    let c = n[o];
+    const f = Object.assign({}, a, {
+      // Nested validations fields are always strict:
+      //    1. parent isn't strict so the casting will also have cast inner values
+      //    2. parent is strict in which case the nested values weren't cast either
+      strict: !0,
+      parent: n,
+      value: c,
+      originalValue: i[o],
+      // FIXME: tests depend on `index` being passed around deeply,
+      //   we should not let the options.key/index bleed through
+      key: void 0,
+      // index: undefined,
+      [u ? "index" : "key"]: o,
+      path: u || o.includes(".") ? `${s || ""}[${u ? o : `"${o}"`}]` : (s ? `${s}.` : "") + e
+    });
+    return (h, y, w) => this.resolve(f)._validate(c, f, y, w);
+  }
+  validate(e, r) {
+    var n;
+    let s = this.resolve(Object.assign({}, r, {
+      value: e
+    })), i = (n = r?.disableStackTrace) != null ? n : s.spec.disableStackTrace;
+    return new Promise((a, o) => s._validate(e, r, (u, c) => {
+      D.isError(u) && (u.value = c), o(u);
+    }, (u, c) => {
+      u.length ? o(new D(u, c, void 0, void 0, i)) : a(c);
+    }));
+  }
+  validateSync(e, r) {
+    var n;
+    let s = this.resolve(Object.assign({}, r, {
+      value: e
+    })), i, a = (n = r?.disableStackTrace) != null ? n : s.spec.disableStackTrace;
+    return s._validate(e, Object.assign({}, r, {
+      sync: !0
+    }), (o, u) => {
+      throw D.isError(o) && (o.value = u), o;
+    }, (o, u) => {
+      if (o.length) throw new D(o, e, void 0, void 0, a);
+      i = u;
+    }), i;
+  }
+  isValid(e, r) {
+    return this.validate(e, r).then(() => !0, (n) => {
+      if (D.isError(n)) return !1;
+      throw n;
+    });
+  }
+  isValidSync(e, r) {
+    try {
+      return this.validateSync(e, r), !0;
+    } catch (n) {
+      if (D.isError(n)) return !1;
+      throw n;
+    }
+  }
+  _getDefault(e) {
+    let r = this.spec.default;
+    return r == null ? r : typeof r == "function" ? r.call(this, e) : J(r);
+  }
+  getDefault(e) {
+    return this.resolve(e || {})._getDefault(e);
+  }
+  default(e) {
+    return arguments.length === 0 ? this._getDefault() : this.clone({
+      default: e
+    });
+  }
+  strict(e = !0) {
+    return this.clone({
+      strict: e
+    });
+  }
+  nullability(e, r) {
+    const n = this.clone({
+      nullable: e
+    });
+    return n.internalTests.nullable = G({
+      message: r,
+      name: "nullable",
+      test(s) {
+        return s === null ? this.schema.spec.nullable : !0;
+      }
+    }), n;
+  }
+  optionality(e, r) {
+    const n = this.clone({
+      optional: e
+    });
+    return n.internalTests.optionality = G({
+      message: r,
+      name: "optionality",
+      test(s) {
+        return s === void 0 ? this.schema.spec.optional : !0;
+      }
+    }), n;
+  }
+  optional() {
+    return this.optionality(!0);
+  }
+  defined(e = M.defined) {
+    return this.optionality(!1, e);
+  }
+  nullable() {
+    return this.nullability(!0);
+  }
+  nonNullable(e = M.notNull) {
+    return this.nullability(!1, e);
+  }
+  required(e = M.required) {
+    return this.clone().withMutation((r) => r.nonNullable(e).defined(e));
+  }
+  notRequired() {
+    return this.clone().withMutation((e) => e.nullable().optional());
+  }
+  transform(e) {
+    let r = this.clone();
+    return r.transforms.push(e), r;
+  }
+  /**
+   * Adds a test function to the schema's queue of tests.
+   * tests can be exclusive or non-exclusive.
+   *
+   * - exclusive tests, will replace any existing tests of the same name.
+   * - non-exclusive: can be stacked
+   *
+   * If a non-exclusive test is added to a schema with an exclusive test of the same name
+   * the exclusive test is removed and further tests of the same name will be stacked.
+   *
+   * If an exclusive test is added to a schema with non-exclusive tests of the same name
+   * the previous tests are removed and further tests of the same name will replace each other.
+   */
+  test(...e) {
+    let r;
+    if (e.length === 1 ? typeof e[0] == "function" ? r = {
+      test: e[0]
+    } : r = e[0] : e.length === 2 ? r = {
+      name: e[0],
+      test: e[1]
+    } : r = {
+      name: e[0],
+      message: e[1],
+      test: e[2]
+    }, r.message === void 0 && (r.message = M.default), typeof r.test != "function") throw new TypeError("`test` is a required parameters");
+    let n = this.clone(), s = G(r), i = r.exclusive || r.name && n.exclusiveTests[r.name] === !0;
+    if (r.exclusive && !r.name)
+      throw new TypeError("Exclusive tests must provide a unique `name` identifying the test");
+    return r.name && (n.exclusiveTests[r.name] = !!r.exclusive), n.tests = n.tests.filter((a) => !(a.OPTIONS.name === r.name && (i || a.OPTIONS.test === s.OPTIONS.test))), n.tests.push(s), n;
+  }
+  when(e, r) {
+    !Array.isArray(e) && typeof e != "string" && (r = e, e = ".");
+    let n = this.clone(), s = nt(e).map((i) => new Q(i));
+    return s.forEach((i) => {
+      i.isSibling && n.deps.push(i.key);
+    }), n.conditions.push(typeof r == "function" ? new fe(s, r) : fe.fromOptions(s, r)), n;
+  }
+  typeError(e) {
+    let r = this.clone();
+    return r.internalTests.typeError = G({
+      message: e,
+      name: "typeError",
+      skipAbsent: !0,
+      test(n) {
+        return this.schema._typeCheck(n) ? !0 : this.createError({
+          params: {
+            type: this.schema.type
+          }
+        });
+      }
+    }), r;
+  }
+  oneOf(e, r = M.oneOf) {
+    let n = this.clone();
+    return e.forEach((s) => {
+      n._whitelist.add(s), n._blacklist.delete(s);
+    }), n.internalTests.whiteList = G({
+      message: r,
+      name: "oneOf",
+      skipAbsent: !0,
+      test(s) {
+        let i = this.schema._whitelist, a = i.resolveAll(this.resolve);
+        return a.includes(s) ? !0 : this.createError({
+          params: {
+            values: Array.from(i).join(", "),
+            resolved: a
+          }
+        });
+      }
+    }), n;
+  }
+  notOneOf(e, r = M.notOneOf) {
+    let n = this.clone();
+    return e.forEach((s) => {
+      n._blacklist.add(s), n._whitelist.delete(s);
+    }), n.internalTests.blacklist = G({
+      message: r,
+      name: "notOneOf",
+      test(s) {
+        let i = this.schema._blacklist, a = i.resolveAll(this.resolve);
+        return a.includes(s) ? this.createError({
+          params: {
+            values: Array.from(i).join(", "),
+            resolved: a
+          }
+        }) : !0;
+      }
+    }), n;
+  }
+  strip(e = !0) {
+    let r = this.clone();
+    return r.spec.strip = e, r;
+  }
+  /**
+   * Return a serialized description of the schema including validations, flags, types etc.
+   *
+   * @param options Provide any needed context for resolving runtime schema alterations (lazy, when conditions, etc).
+   */
+  describe(e) {
+    const r = (e ? this.resolve(e) : this).clone(), {
+      label: n,
+      meta: s,
+      optional: i,
+      nullable: a
+    } = r.spec;
+    return {
+      meta: s,
+      label: n,
+      optional: i,
+      nullable: a,
+      default: r.getDefault(e),
+      type: r.type,
+      oneOf: r._whitelist.describe(),
+      notOneOf: r._blacklist.describe(),
+      tests: r.tests.filter((u, c, f) => f.findIndex((h) => h.OPTIONS.name === u.OPTIONS.name) === c).map((u) => {
+        const c = u.OPTIONS.params && e ? lt(Object.assign({}, u.OPTIONS.params), e) : u.OPTIONS.params;
+        return {
+          name: u.OPTIONS.name,
+          params: c
+        };
+      })
+    };
+  }
+  get "~standard"() {
+    const e = this;
+    return {
+      version: 1,
+      vendor: "yup",
+      async validate(n) {
+        try {
+          return {
+            value: await e.validate(n, {
+              abortEarly: !1
+            })
+          };
+        } catch (s) {
+          if (s instanceof D)
+            return {
+              issues: ct(s)
+            };
+          throw s;
+        }
+      }
+    };
+  }
+}
+U.prototype.__isYupSchema__ = !0;
+for (const t of ["validate", "validateSync"]) U.prototype[`${t}At`] = function(e, r, n = {}) {
+  const {
+    parent: s,
+    parentPath: i,
+    schema: a
+  } = er(this, e, r, n.context);
+  return a[t](s && s[i], Object.assign({}, n, {
+    parent: s,
+    path: e
+  }));
+};
+for (const t of ["equals", "is"]) U.prototype[t] = U.prototype.oneOf;
+for (const t of ["not", "nope"]) U.prototype[t] = U.prototype.notOneOf;
+const nr = /^(\d{4}|[+-]\d{6})(?:-?(\d{2})(?:-?(\d{2}))?)?(?:[ T]?(\d{2}):?(\d{2})(?::?(\d{2})(?:[,.](\d{1,}))?)?(?:(Z)|([+-])(\d{2})(?::?(\d{2}))?)?)?$/;
+function sr(t) {
+  const e = xe(t);
+  if (!e) return Date.parse ? Date.parse(t) : Number.NaN;
+  if (e.z === void 0 && e.plusMinus === void 0)
+    return new Date(e.year, e.month, e.day, e.hour, e.minute, e.second, e.millisecond).valueOf();
+  let r = 0;
+  return e.z !== "Z" && e.plusMinus !== void 0 && (r = e.hourOffset * 60 + e.minuteOffset, e.plusMinus === "+" && (r = 0 - r)), Date.UTC(e.year, e.month, e.day, e.hour, e.minute + r, e.second, e.millisecond);
+}
+function xe(t) {
+  var e, r;
+  const n = nr.exec(t);
+  return n ? {
+    year: j(n[1]),
+    month: j(n[2], 1) - 1,
+    day: j(n[3], 1),
+    hour: j(n[4]),
+    minute: j(n[5]),
+    second: j(n[6]),
+    millisecond: n[7] ? (
+      // allow arbitrary sub-second precision beyond milliseconds
+      j(n[7].substring(0, 3))
+    ) : 0,
+    precision: (e = (r = n[7]) == null ? void 0 : r.length) != null ? e : void 0,
+    z: n[8] || void 0,
+    plusMinus: n[9] || void 0,
+    hourOffset: j(n[10]),
+    minuteOffset: j(n[11])
+  } : null;
+}
+function j(t, e = 0) {
+  return Number(t) || e;
+}
+let ir = (
+  // eslint-disable-next-line
+  /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
+), ar = (
+  // eslint-disable-next-line
+  /^((https?|ftp):)?\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i
+), or = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i, lr = "^\\d{4}-\\d{2}-\\d{2}", ur = "\\d{2}:\\d{2}:\\d{2}", cr = "(([+-]\\d{2}(:?\\d{2})?)|Z)", fr = new RegExp(`${lr}T${ur}(\\.\\d+)?${cr}$`), hr = (t) => q(t) || t === t.trim(), dr = {}.toString();
+function pr() {
+  return new ft();
+}
+class ft extends U {
+  constructor() {
+    super({
+      type: "string",
+      check(e) {
+        return e instanceof String && (e = e.valueOf()), typeof e == "string";
+      }
+    }), this.withMutation(() => {
+      this.transform((e, r) => {
+        if (!this.spec.coerce || this.isType(e) || Array.isArray(e)) return e;
+        const n = e != null && e.toString ? e.toString() : e;
+        return n === dr ? e : n;
+      });
+    });
+  }
+  required(e) {
+    return super.required(e).withMutation((r) => r.test({
+      message: e || M.required,
+      name: "required",
+      skipAbsent: !0,
+      test: (n) => !!n.length
+    }));
+  }
+  notRequired() {
+    return super.notRequired().withMutation((e) => (e.tests = e.tests.filter((r) => r.OPTIONS.name !== "required"), e));
+  }
+  length(e, r = _.length) {
+    return this.test({
+      message: r,
+      name: "length",
+      exclusive: !0,
+      params: {
+        length: e
+      },
+      skipAbsent: !0,
+      test(n) {
+        return n.length === this.resolve(e);
+      }
+    });
+  }
+  min(e, r = _.min) {
+    return this.test({
+      message: r,
+      name: "min",
+      exclusive: !0,
+      params: {
+        min: e
+      },
+      skipAbsent: !0,
+      test(n) {
+        return n.length >= this.resolve(e);
+      }
+    });
+  }
+  max(e, r = _.max) {
+    return this.test({
+      name: "max",
+      exclusive: !0,
+      message: r,
+      params: {
+        max: e
+      },
+      skipAbsent: !0,
+      test(n) {
+        return n.length <= this.resolve(e);
+      }
+    });
+  }
+  matches(e, r) {
+    let n = !1, s, i;
+    return r && (typeof r == "object" ? {
+      excludeEmptyString: n = !1,
+      message: s,
+      name: i
+    } = r : s = r), this.test({
+      name: i || "matches",
+      message: s || _.matches,
+      params: {
+        regex: e
+      },
+      skipAbsent: !0,
+      test: (a) => a === "" && n || a.search(e) !== -1
+    });
+  }
+  email(e = _.email) {
+    return this.matches(ir, {
+      name: "email",
+      message: e,
+      excludeEmptyString: !0
+    });
+  }
+  url(e = _.url) {
+    return this.matches(ar, {
+      name: "url",
+      message: e,
+      excludeEmptyString: !0
+    });
+  }
+  uuid(e = _.uuid) {
+    return this.matches(or, {
+      name: "uuid",
+      message: e,
+      excludeEmptyString: !1
+    });
+  }
+  datetime(e) {
+    let r = "", n, s;
+    return e && (typeof e == "object" ? {
+      message: r = "",
+      allowOffset: n = !1,
+      precision: s = void 0
+    } = e : r = e), this.matches(fr, {
+      name: "datetime",
+      message: r || _.datetime,
+      excludeEmptyString: !0
+    }).test({
+      name: "datetime_offset",
+      message: r || _.datetime_offset,
+      params: {
+        allowOffset: n
+      },
+      skipAbsent: !0,
+      test: (i) => {
+        if (!i || n) return !0;
+        const a = xe(i);
+        return a ? !!a.z : !1;
+      }
+    }).test({
+      name: "datetime_precision",
+      message: r || _.datetime_precision,
+      params: {
+        precision: s
+      },
+      skipAbsent: !0,
+      test: (i) => {
+        if (!i || s == null) return !0;
+        const a = xe(i);
+        return a ? a.precision === s : !1;
+      }
+    });
+  }
+  //-- transforms --
+  ensure() {
+    return this.default("").transform((e) => e === null ? "" : e);
+  }
+  trim(e = _.trim) {
+    return this.transform((r) => r != null ? r.trim() : r).test({
+      message: e,
+      name: "trim",
+      test: hr
+    });
+  }
+  lowercase(e = _.lowercase) {
+    return this.transform((r) => q(r) ? r : r.toLowerCase()).test({
+      message: e,
+      name: "string_case",
+      exclusive: !0,
+      skipAbsent: !0,
+      test: (r) => q(r) || r === r.toLowerCase()
+    });
+  }
+  uppercase(e = _.uppercase) {
+    return this.transform((r) => q(r) ? r : r.toUpperCase()).test({
+      message: e,
+      name: "string_case",
+      exclusive: !0,
+      skipAbsent: !0,
+      test: (r) => q(r) || r === r.toUpperCase()
+    });
+  }
+}
+pr.prototype = ft.prototype;
+let mr = /* @__PURE__ */ new Date(""), gr = (t) => Object.prototype.toString.call(t) === "[object Date]";
+class Ce extends U {
+  constructor() {
+    super({
+      type: "date",
+      check(e) {
+        return gr(e) && !isNaN(e.getTime());
+      }
+    }), this.withMutation(() => {
+      this.transform((e, r) => !this.spec.coerce || this.isType(e) || e === null ? e : (e = sr(e), isNaN(e) ? Ce.INVALID_DATE : new Date(e)));
+    });
+  }
+  prepareParam(e, r) {
+    let n;
+    if (Q.isRef(e))
+      n = e;
+    else {
+      let s = this.cast(e);
+      if (!this._typeCheck(s)) throw new TypeError(`\`${r}\` must be a Date or a value that can be \`cast()\` to a Date`);
+      n = s;
+    }
+    return n;
+  }
+  min(e, r = Oe.min) {
+    let n = this.prepareParam(e, "min");
+    return this.test({
+      message: r,
+      name: "min",
+      exclusive: !0,
+      params: {
+        min: e
+      },
+      skipAbsent: !0,
+      test(s) {
+        return s >= this.resolve(n);
+      }
+    });
+  }
+  max(e, r = Oe.max) {
+    let n = this.prepareParam(e, "max");
+    return this.test({
+      message: r,
+      name: "max",
+      exclusive: !0,
+      params: {
+        max: e
+      },
+      skipAbsent: !0,
+      test(s) {
+        return s <= this.resolve(n);
+      }
+    });
+  }
+}
+Ce.INVALID_DATE = mr;
+var br = /* @__PURE__ */ ((t) => (t.visitpad = "/md/viewPatientDashboard.php", t.consultations = "/md/viewPatientList.php", t.appointments = "/md/viewPatientAppointments.php", t.settings = "/md/viewPreferenceSettings.php", t.privateDb = "/md/viewPrivateDB.php", t.dashboardBase = "/", t.referEarn = "/md/inviteReferrals.php", t.teleConsults = "/md/viewRemoteAppointments.php", t.pricing = "/subscription/pricing", t.billSummary = "/subscription/bill-summary", t.pediatricsCalculator = "/md/viewPediatricCalculator.php", t))(br || {}), yr = /* @__PURE__ */ ((t) => (t.PRODUCTION = "PRODUCTION", t.STAGING = "STAGING", t.DEVELOPMENT = "DEVELOPMENT", t))(yr || {}), wr = /* @__PURE__ */ ((t) => (t.visitpad = "/md/viewPatientDashboard.php", t.consultations = "/md/viewPatientList.php", t.appointments = "/md/viewPatientAppointments.php", t.settings = "/md/viewPreferenceSettings.php", t.privateDb = "/md/viewPrivateDB.php", t.dashboardBase = "/", t.referEarn = "/md/inviteReferrals.php", t.teleConsults = "/md/viewRemoteAppointments.php", t.pricing = "/subscription/pricing", t.billSummary = "/subscription/bill-summary", t.pediatricsCalculator = "/md/viewPediatricCalculator.php", t))(wr || {});
+const hs = [
+  "Salaried Professional",
+  "Doctor",
+  "Teacher",
+  "Accountant",
+  "Lawyer",
+  "Farmer",
+  "Business Owner",
+  "Freelancer",
+  "Retail Worker",
+  "Others"
+], ds = [
+  "Visakhapatnam",
+  "Vijayawada",
+  "Guntur",
+  "Nellore",
+  "Kurnool",
+  "Rajahmundry",
+  "Tirupati",
+  "Kadapa",
+  "Kakinada",
+  "Eluru",
+  "Anantapur",
+  "Vijayanagaram",
+  "Ongole",
+  "Nandyal",
+  "Chittoor",
+  "Machilipatnam",
+  "Adoni",
+  "Tenali",
+  "Proddatur",
+  "Hindupur",
+  "Bhimavaram",
+  "Madanapalle",
+  "Guntakal",
+  "Srikakulam",
+  "Dharmavaram",
+  "Gudivada",
+  "Narasaraopet",
+  "Tadipatri",
+  "Kavali",
+  "Tadepalligudem",
+  "Amaravati",
+  "Guwahati",
+  "Patna",
+  "Gaya",
+  "Bhagalpur",
+  "Muzaffarpur",
+  "Bihar Sharif",
+  "Darbhanga",
+  "Purnia",
+  "Arrah",
+  "Begusarai",
+  "Katihar",
+  "Munger",
+  "Chapra",
+  "Danapur",
+  "Saharsa",
+  "Sasaram",
+  "Hajipur",
+  "Dehri",
+  "Siwan",
+  "Bettiah",
+  "Motihari",
+  "Bagaha",
+  "Kishanganj",
+  "Jamalpur",
+  "Buxar",
+  "Jehanabad",
+  "Aurangabad",
+  "Chandigarh",
+  "Raipur",
+  "Bhilai",
+  "Korba",
+  "Bilaspur",
+  "Durg",
+  "Delhi",
+  "Kirari Suleman Nagar",
+  "New Delhi",
+  "Karawal Nagar",
+  "Nangloi Jat",
+  "Bhalswa Jahangir Pur",
+  "Sultan Pur Majra",
+  "Ahmedabad",
+  "Surat",
+  "Vadodara",
+  "Rajkot",
+  "Bhavnagar",
+  "Jamnagar",
+  "Junagadh",
+  "Gandhidham",
+  "Nadiad",
+  "Gandhinagar",
+  "Anand",
+  "Morvi",
+  "Mahesana",
+  "Surendranagar Dudhrej",
+  "Faridabad",
+  "Gurgaon",
+  "Rohtak",
+  "Panipat",
+  "Karnal",
+  "Sonipat",
+  "Yamunanagar",
+  "Panchkula",
+  "Bhiwani",
+  "Ambala",
+  "Sirsa",
+  "Shimla",
+  "Srinagar",
+  "Jammu",
+  "Dhanbad",
+  "Ranchi",
+  "Jamshedpur",
+  "Bokaro",
+  "Mango",
+  "Deoghar",
+  "Bangalore",
+  "Hubballi-Dharwad",
+  "Mysore",
+  "Gulbarga",
+  "Mangalore",
+  "Belgaum",
+  "Davanagere",
+  "Bellary",
+  "Bijapur",
+  "Shivamogga",
+  "Tumkur",
+  "Raichur",
+  "Bidar",
+  "Hospet",
+  "Thiruvananthapuram",
+  "Kochi",
+  "Kozhikode",
+  "Kollam",
+  "Thrissur",
+  "Alappuzha",
+  "Kottayam",
+  "Indore",
+  "Bhopal",
+  "Jabalpur",
+  "Gwalior",
+  "Ujjain",
+  "Dewas",
+  "Satna",
+  "Sagar",
+  "Ratlam",
+  "Rewa",
+  "Singrauli",
+  "Burhanpur",
+  "Khandwa",
+  "Morena",
+  "Bhind",
+  "Guna",
+  "Shivpuri",
+  "Mumbai",
+  "Pune",
+  "Nagpur",
+  "Thane",
+  "Pimpri-Chinchwad",
+  "Nashik",
+  "Kalyan-Dombivali",
+  "Vasai-Virar",
+  "Aurangabad",
+  "Navi Mumbai",
+  "Solapur",
+  "Mira-Bhayandar",
+  "Bhiwandi",
+  "Amravati",
+  "Nanded",
+  "Kolhapur",
+  "Akola",
+  "Ulhasnagar",
+  "Sangli-Miraj & Kupwad",
+  "Malegaon",
+  "Jalgaon",
+  "Latur",
+  "Dhule",
+  "Ahmednagar",
+  "Satara",
+  "Chandrapur",
+  "Parbhani",
+  "Ichalkaranji",
+  "Jalna",
+  "Ambernath",
+  "Navi Mumbai Panvel Raigad",
+  "Bhusawal",
+  "Panvel",
+  "Imphal",
+  "Aizawl",
+  "Bhubaneswar",
+  "Cuttack",
+  "Rourkela",
+  "Berhampur",
+  "Sambalpur",
+  "Rourkela",
+  "Raurkela Industrial Township",
+  "Sambalpur",
+  "Ozhukarai",
+  "Puducherry",
+  "Ludhiana",
+  "Amritsar",
+  "Jalandhar",
+  "Patiala",
+  "Bathinda",
+  "Jaipur",
+  "Jodhpur",
+  "Kota",
+  "Bikaner",
+  "Ajmer",
+  "Udaipur",
+  "Bhilwara",
+  "Alwar",
+  "Bharatpur",
+  "Sikar",
+  "Pali",
+  "Sri Ganganagar",
+  "Chennai",
+  "Coimbatore",
+  "Madurai",
+  "Tiruchirappalli",
+  "Tiruppur",
+  "Salem",
+  "Erode",
+  "Ambattur",
+  "Tirunelveli",
+  "Avadi",
+  "Tiruvottiyur",
+  "Thoothukudi",
+  "Nagarcoil",
+  "Thanjavur",
+  "Pallavaram",
+  "Dindigul",
+  "Vellore",
+  "Karaikudi",
+  "Hyderabad",
+  "Warangal",
+  "Nizamabad",
+  "Khammam",
+  "Karimnagar",
+  "Ramagundam",
+  "Secunderabad",
+  "Miryalaguda",
+  "Suryapet",
+  "Agartala",
+  "Lucknow",
+  "Kanpur",
+  "Ghaziabad",
+  "Agra",
+  "Meerut",
+  "Varanasi",
+  "Prayagraj",
+  "Moradabad",
+  "Bareily",
+  "Aligarh",
+  "Saharanpur",
+  "Gorakhpur",
+  "Noida",
+  "Firozabad",
+  "Loni",
+  "Jhansi",
+  "Muzaffarnagar",
+  "Mathura",
+  "Shahjahanpur",
+  "Rampur",
+  "Mau",
+  "Farrukhabad",
+  "Hapur",
+  "Etawah",
+  "Mirzapur",
+  "Bulandshahr",
+  "Murwara",
+  "Sambhal",
+  "Amroha",
+  "Fatehpur",
+  "Rae Bareli",
+  "Khora",
+  "Orai",
+  "Bahraich",
+  "Jaunpur",
+  "Unnao",
+  "Dehradun",
+  "Haridwar",
+  "Kolkata",
+  "Howrah",
+  "Durgapur",
+  "Asansol",
+  "Siliguri",
+  "Maheshtala",
+  "Rajpur Sonarpur",
+  "South Dumdum",
+  "Gopalpur",
+  "Bhatpara",
+  "Panihati",
+  "Kamarhati",
+  "Bardhaman",
+  "Kulti",
+  "Bally",
+  "Barasat",
+  "North Dumdum",
+  "Baranagar",
+  "Uluberia",
+  "Naihati",
+  "Bidhan Nagar",
+  "Kharagpur",
+  "Malda",
+  "Haldia",
+  "Madhyamgram",
+  "Baharampur",
+  "Raiganj",
+  "Serampore",
+  "Pratapgarh",
+  "Sultanpur",
+  "Amethi"
+], ps = [
+  { label: "", value: "", gender: "" },
+  { label: "Mr", value: "Mr", gender: "0" },
+  { label: "Mrs", value: "Mrs", gender: "1" },
+  { label: "Ms", value: "Ms", gender: "1" },
+  { label: "Dr", value: "Dr", gender: "" },
+  { label: "Md", value: "Md", gender: "0" },
+  { label: "Smt", value: "Smt", gender: "1" },
+  { label: "Baby", value: "Baby", gender: "1" },
+  { label: "Master", value: "Master", gender: "0" },
+  { label: "Sri", value: "Sri", gender: "0" },
+  { label: "Kumari", value: "Kumari", gender: "1" }
+], ms = [
+  { value: "", label: "Blood Group" },
+  { value: "A+ve", label: "A +ve" },
+  { value: "A-ve", label: "A -ve" },
+  { value: "B+ve", label: "B +ve" },
+  { value: "B-ve", label: "B -ve" },
+  { value: "AB+ve", label: "AB +ve" },
+  { value: "AB-ve", label: "AB -ve" },
+  { value: "O+ve", label: "O +ve" },
+  { value: "O-ve", label: "O -ve" }
+], gs = {
+  en: "English",
+  hi: "Hindi",
+  kn: "Kannada",
+  ml: "Malayalam",
+  te: "Telugu",
+  gu: "Gujarati",
+  mr: "Marathi",
+  ta: "Tamil",
+  bn: "Bengali",
+  ur: "Urdu",
+  pa: "Punjabi",
+  od: "Oriya",
+  ar: "Arabic",
+  asa: "Assamese"
+}, bs = [
+  { label: "Cardiologist", value: "Cardiologist" },
+  { label: "Dental", value: "Dental" },
+  { label: "Dermatologist", value: "Dermatologist" },
+  { label: "Dietician", value: "Dietician" },
+  { label: "Endocrinologist", value: "Endocrinologist" },
+  { label: "Gastroenterologist", value: "Gastroenterologist" },
+  { label: "Gynecologist", value: "Gynecologist" },
+  { label: "Hematologist", value: "Hematologist" },
+  { label: "Hepatologist", value: "Hepatologist" },
+  { label: "Immunologist", value: "Immunologist" },
+  { label: "Nephrologist", value: "Nephrologist" },
+  { label: "Neurologist", value: "Neurologist" },
+  { label: "Neurosurgeon", value: "Neurosurgeon" },
+  { label: "Ophthalmologist", value: "Ophthalmologist" },
+  { label: "Orthopedician", value: "Orthopedician" },
+  { label: "Pediatrician", value: "Pediatrician" },
+  { label: "Physician", value: "Physician" },
+  { label: "Plastic surgery", value: "Plastic surgery" },
+  { label: "Podiatrist", value: "Podiatrist" },
+  { label: "Pulmonologist", value: "Pulmonologist" },
+  { label: "Surgeon", value: "Surgeon" },
+  { label: "Urologist", value: "Urologist" },
+  { label: "ENT", value: "ENT" },
+  { label: "Psychiatrist", value: "Psychiatrist" },
+  { label: "Rheumatologist", value: "Rheumatologist" },
+  { label: "Surgical Gastrenterologist", value: "Surgical Gastrenterologist" },
+  { label: "Oncologist", value: "Oncologist" },
+  { label: "Diabetologist", value: "Diabetologist" },
+  { label: "CVT surgeon", value: "CVT surgeon" },
+  { label: "Vascular surgeon", value: "Vascular surgeon" },
+  { label: "Dental surgeon", value: "Dental surgeon" },
+  { label: "Physiotherapist", value: "Physiotherapist" },
+  { label: "General Surgeon", value: "General Surgeon" },
+  { label: "Foot Surgeon", value: "Foot Surgeon" },
+  { label: "Psychologist", value: "Psychologist" },
+  { label: "Counsellor", value: "Counsellor" },
+  { label: "Nutritionist", value: "Nutritionist" },
+  { label: "Pathologist", value: "Pathologist" },
+  { label: "Retina Surgeon", value: "Retina Surgeon" },
+  { label: "Nuclear Medicine", value: "Nuclear Medicine" },
+  { label: "Neuro Physician", value: "Neuro Physician" },
+  { label: "Ortho Surgeon", value: "Ortho Surgeon" },
+  { label: "Radiologist", value: "Radiologist" },
+  { label: "General Physician", value: "General Physician" },
+  { label: "TAVI Specialist", value: "TAVI Specialist" }
+], Sr = [
+  { value: 0, text: "Male" },
+  { value: 1, text: "Female" },
+  { value: 2, text: "Other" }
+], ys = ["Single", "Married", "Divorcee", "Widow"], Er = {
+  title: "Session Timed Out.",
+  subTitle: "Please Login again.",
+  type: "Error",
+  time: 3e4
+}, ht = {
+  STAGING: {
+    php_url: "https://consultation-edge-dev.healthplix.com/",
+    rearch_url: "https://consultation-edge-dev.healthplix.com/"
+  },
+  DEVELOPMENT: {
+    php_url: "https://consultation-edge-dev.healthplix.com/",
+    rearch_url: "https://consultation-edge-dev.healthplix.com/"
+  },
+  PRODUCTION: {
+    php_url: "https://consultation-edge-dev.healthplix.com/",
+    rearch_url: "https://consultation-edge.healthplix.com/"
+  }
+}, ws = (t) => {
+  window.location.href = t;
+}, Ss = (t) => {
+  const e = [];
+  if (t.length)
+    for (const r of t)
+      e.push({ title: r, value: r });
+  return e;
+}, Es = (t) => {
+  const e = [];
+  if (t.length)
+    for (const r of t)
+      e.push({
+        doctor_id: r.doctor_id ? r.doctor_id : "",
+        doctor_name: r.doctor_name ? r.doctor_name : "",
+        label: r.doctor_name ? r.doctor_name : "",
+        specialist: r.specialist || ""
+      });
+  return e;
+}, Ts = (t) => {
+  try {
+    JSON.parse(t);
+  } catch (e) {
+    return console.log("Error parsing JSON:", e), !1;
+  }
+  return !0;
+}, vs = (t, e) => {
+  if (e?.length) {
+    const r = e.toLowerCase();
+    if (t && (r === "day" || r === "days" || r === "weeks" || r === "months" || r === "years")) {
+      t = t ? t.toString() : "";
+      const n = I().subtract(Number(t.replace(/[^0-9]/g, "")), r);
+      return I(n).format("YYYY-MM-DD");
+    }
+    return null;
+  }
+  return null;
+}, As = (t) => {
+  switch (t) {
+    case "0":
+      return "M";
+    case "1":
+      return "F";
+    case "2":
+      return "O";
+    default:
+      return "O";
+  }
+}, Os = (t) => {
+  const e = Sr.find((r) => r.value === t);
+  return e && e.text ? e.text.slice(0, 1) : "";
+}, xs = (t) => {
+  let e = "";
+  return new RegExp("^[0-9]{10}$").test(t) ? { isError: !1, msg: e } : (t.length < 10 ? e = "Please enter 10 digit number" : t.length > 10 ? e = "Invalid phone number. Should have at most 10 digits." : /^\d+$/.test(t) ? e = "Please enter 10 digit number" : e = "Invalid phone number. Should contain only digits.", {
+    isError: !0,
+    msg: e
+  });
+}, Rs = (t) => t ? new Date(t).toString() !== "Invalid Date" : !1;
+function Fs(t) {
+  const e = I(t).format("YYYY-MM-DD"), r = new Date(e), s = Math.abs((/* @__PURE__ */ new Date()).getTime() - r.getTime()), i = Math.ceil(s / (1e3 * 60 * 60 * 24));
+  if (i <= 7)
+    return `${i} days`;
+  if (i <= 30)
+    return `${Math.floor(i / 7)} weeks`;
+  if (i <= 365)
+    return `${Math.floor(i / 30)} months`;
+  {
+    const a = Math.floor(i / 365);
+    return isNaN(a) ? "" : `${a} years`;
+  }
+}
+const Ds = (t, e = 300) => {
+  let r = null;
+  return function(...n) {
+    r && clearTimeout(r), r = setTimeout(() => {
+      r = null, t.apply(this, n);
+    }, e);
+  };
+}, _s = (t, e) => {
+  if (e?.length) {
+    const r = e.toLowerCase();
+    if (t && (r === "day" || r === "days" || r === "weeks" || r === "months" || r === "years")) {
+      t = t ? t.toString() : "";
+      const n = I().subtract(Number(t.replace(/[^0-9]/g, "")), r);
+      return I(n).format("YYYY-MM-DD");
+    }
+    return null;
+  }
+  return null;
+}, dt = () => {
+  const { title: t, subTitle: e, type: r, time: n } = Er;
+  typeof window.showToast == "function" && window.showToast(t, e, r, n);
+};
+function Ns(t = "") {
+  return t ? t.charAt(0).toUpperCase() + t.slice(1) : "";
+}
+const Ps = (t, e = "") => {
+  const r = e?.length && e?.trim() ? e?.trim() : "";
+  try {
+    if (typeof t == "string" && t?.length && t?.trim()) {
+      const n = t.replace(/\s+/g, " ").trim().split(" ");
+      return n?.length ? {
+        duration: n[0] || "",
+        durationType: n[1]?.length ? n[1] : r || ""
+      } : {
+        duration: "",
+        durationType: ""
+      };
+    }
+    return {
+      duration: t ? `${t}` : "",
+      durationType: r
+    };
+  } catch (n) {
+    return console.log(n, "getDurationFormat"), {
+      duration: "",
+      durationType: ""
+    };
+  }
+};
+function pt(t, e) {
+  return function() {
+    return t.apply(e, arguments);
+  };
+}
+const { toString: Tr } = Object.prototype, { getPrototypeOf: ke } = Object, { iterator: me, toStringTag: mt } = Symbol, ge = /* @__PURE__ */ ((t) => (e) => {
+  const r = Tr.call(e);
+  return t[r] || (t[r] = r.slice(8, -1).toLowerCase());
+})(/* @__PURE__ */ Object.create(null)), $ = (t) => (t = t.toLowerCase(), (e) => ge(e) === t), be = (t) => (e) => typeof e === t, { isArray: K } = Array, Z = be("undefined");
+function ee(t) {
+  return t !== null && !Z(t) && t.constructor !== null && !Z(t.constructor) && N(t.constructor.isBuffer) && t.constructor.isBuffer(t);
+}
+const gt = $("ArrayBuffer");
+function vr(t) {
+  let e;
+  return typeof ArrayBuffer < "u" && ArrayBuffer.isView ? e = ArrayBuffer.isView(t) : e = t && t.buffer && gt(t.buffer), e;
+}
+const Ar = be("string"), N = be("function"), bt = be("number"), te = (t) => t !== null && typeof t == "object", Or = (t) => t === !0 || t === !1, le = (t) => {
+  if (ge(t) !== "object")
+    return !1;
+  const e = ke(t);
+  return (e === null || e === Object.prototype || Object.getPrototypeOf(e) === null) && !(mt in t) && !(me in t);
+}, xr = (t) => {
+  if (!te(t) || ee(t))
+    return !1;
+  try {
+    return Object.keys(t).length === 0 && Object.getPrototypeOf(t) === Object.prototype;
+  } catch {
+    return !1;
+  }
+}, Rr = $("Date"), Fr = $("File"), Dr = $("Blob"), _r = $("FileList"), Nr = (t) => te(t) && N(t.pipe), Pr = (t) => {
+  let e;
+  return t && (typeof FormData == "function" && t instanceof FormData || N(t.append) && ((e = ge(t)) === "formdata" || // detect form-data instance
+  e === "object" && N(t.toString) && t.toString() === "[object FormData]"));
+}, Cr = $("URLSearchParams"), [kr, $r, Br, Mr] = ["ReadableStream", "Request", "Response", "Headers"].map($), jr = (t) => t.trim ? t.trim() : t.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
+function re(t, e, { allOwnKeys: r = !1 } = {}) {
+  if (t === null || typeof t > "u")
+    return;
+  let n, s;
+  if (typeof t != "object" && (t = [t]), K(t))
+    for (n = 0, s = t.length; n < s; n++)
+      e.call(null, t[n], n, t);
+  else {
+    if (ee(t))
+      return;
+    const i = r ? Object.getOwnPropertyNames(t) : Object.keys(t), a = i.length;
+    let o;
+    for (n = 0; n < a; n++)
+      o = i[n], e.call(null, t[o], o, t);
+  }
+}
+function yt(t, e) {
+  if (ee(t))
+    return null;
+  e = e.toLowerCase();
+  const r = Object.keys(t);
+  let n = r.length, s;
+  for (; n-- > 0; )
+    if (s = r[n], e === s.toLowerCase())
+      return s;
+  return null;
+}
+const z = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : global, wt = (t) => !Z(t) && t !== z;
+function Re() {
+  const { caseless: t } = wt(this) && this || {}, e = {}, r = (n, s) => {
+    const i = t && yt(e, s) || s;
+    le(e[i]) && le(n) ? e[i] = Re(e[i], n) : le(n) ? e[i] = Re({}, n) : K(n) ? e[i] = n.slice() : e[i] = n;
+  };
+  for (let n = 0, s = arguments.length; n < s; n++)
+    arguments[n] && re(arguments[n], r);
+  return e;
+}
+const Ir = (t, e, r, { allOwnKeys: n } = {}) => (re(e, (s, i) => {
+  r && N(s) ? t[i] = pt(s, r) : t[i] = s;
+}, { allOwnKeys: n }), t), Lr = (t) => (t.charCodeAt(0) === 65279 && (t = t.slice(1)), t), Ur = (t, e, r, n) => {
+  t.prototype = Object.create(e.prototype, n), t.prototype.constructor = t, Object.defineProperty(t, "super", {
+    value: e.prototype
+  }), r && Object.assign(t.prototype, r);
+}, qr = (t, e, r, n) => {
+  let s, i, a;
+  const o = {};
+  if (e = e || {}, t == null) return e;
+  do {
+    for (s = Object.getOwnPropertyNames(t), i = s.length; i-- > 0; )
+      a = s[i], (!n || n(a, t, e)) && !o[a] && (e[a] = t[a], o[a] = !0);
+    t = r !== !1 && ke(t);
+  } while (t && (!r || r(t, e)) && t !== Object.prototype);
+  return e;
+}, zr = (t, e, r) => {
+  t = String(t), (r === void 0 || r > t.length) && (r = t.length), r -= e.length;
+  const n = t.indexOf(e, r);
+  return n !== -1 && n === r;
+}, Hr = (t) => {
+  if (!t) return null;
+  if (K(t)) return t;
+  let e = t.length;
+  if (!bt(e)) return null;
+  const r = new Array(e);
+  for (; e-- > 0; )
+    r[e] = t[e];
+  return r;
+}, Vr = /* @__PURE__ */ ((t) => (e) => t && e instanceof t)(typeof Uint8Array < "u" && ke(Uint8Array)), Gr = (t, e) => {
+  const n = (t && t[me]).call(t);
+  let s;
+  for (; (s = n.next()) && !s.done; ) {
+    const i = s.value;
+    e.call(t, i[0], i[1]);
+  }
+}, Jr = (t, e) => {
+  let r;
+  const n = [];
+  for (; (r = t.exec(e)) !== null; )
+    n.push(r);
+  return n;
+}, Kr = $("HTMLFormElement"), Yr = (t) => t.toLowerCase().replace(
+  /[-_\s]([a-z\d])(\w*)/g,
+  function(r, n, s) {
+    return n.toUpperCase() + s;
+  }
+), ze = (({ hasOwnProperty: t }) => (e, r) => t.call(e, r))(Object.prototype), Wr = $("RegExp"), St = (t, e) => {
+  const r = Object.getOwnPropertyDescriptors(t), n = {};
+  re(r, (s, i) => {
+    let a;
+    (a = e(s, i, t)) !== !1 && (n[i] = a || s);
+  }), Object.defineProperties(t, n);
+}, Xr = (t) => {
+  St(t, (e, r) => {
+    if (N(t) && ["arguments", "caller", "callee"].indexOf(r) !== -1)
+      return !1;
+    const n = t[r];
+    if (N(n)) {
+      if (e.enumerable = !1, "writable" in e) {
+        e.writable = !1;
+        return;
+      }
+      e.set || (e.set = () => {
+        throw Error("Can not rewrite read-only method '" + r + "'");
+      });
+    }
+  });
+}, Zr = (t, e) => {
+  const r = {}, n = (s) => {
+    s.forEach((i) => {
+      r[i] = !0;
+    });
+  };
+  return K(t) ? n(t) : n(String(t).split(e)), r;
+}, Qr = () => {
+}, en = (t, e) => t != null && Number.isFinite(t = +t) ? t : e;
+function tn(t) {
+  return !!(t && N(t.append) && t[mt] === "FormData" && t[me]);
+}
+const rn = (t) => {
+  const e = new Array(10), r = (n, s) => {
+    if (te(n)) {
+      if (e.indexOf(n) >= 0)
+        return;
+      if (ee(n))
+        return n;
+      if (!("toJSON" in n)) {
+        e[s] = n;
+        const i = K(n) ? [] : {};
+        return re(n, (a, o) => {
+          const u = r(a, s + 1);
+          !Z(u) && (i[o] = u);
+        }), e[s] = void 0, i;
+      }
+    }
+    return n;
+  };
+  return r(t, 0);
+}, nn = $("AsyncFunction"), sn = (t) => t && (te(t) || N(t)) && N(t.then) && N(t.catch), Et = ((t, e) => t ? setImmediate : e ? ((r, n) => (z.addEventListener("message", ({ source: s, data: i }) => {
+  s === z && i === r && n.length && n.shift()();
+}, !1), (s) => {
+  n.push(s), z.postMessage(r, "*");
+}))(`axios@${Math.random()}`, []) : (r) => setTimeout(r))(
+  typeof setImmediate == "function",
+  N(z.postMessage)
+), an = typeof queueMicrotask < "u" ? queueMicrotask.bind(z) : typeof process < "u" && process.nextTick || Et, on = (t) => t != null && N(t[me]), l = {
+  isArray: K,
+  isArrayBuffer: gt,
+  isBuffer: ee,
+  isFormData: Pr,
+  isArrayBufferView: vr,
+  isString: Ar,
+  isNumber: bt,
+  isBoolean: Or,
+  isObject: te,
+  isPlainObject: le,
+  isEmptyObject: xr,
+  isReadableStream: kr,
+  isRequest: $r,
+  isResponse: Br,
+  isHeaders: Mr,
+  isUndefined: Z,
+  isDate: Rr,
+  isFile: Fr,
+  isBlob: Dr,
+  isRegExp: Wr,
+  isFunction: N,
+  isStream: Nr,
+  isURLSearchParams: Cr,
+  isTypedArray: Vr,
+  isFileList: _r,
+  forEach: re,
+  merge: Re,
+  extend: Ir,
+  trim: jr,
+  stripBOM: Lr,
+  inherits: Ur,
+  toFlatObject: qr,
+  kindOf: ge,
+  kindOfTest: $,
+  endsWith: zr,
+  toArray: Hr,
+  forEachEntry: Gr,
+  matchAll: Jr,
+  isHTMLForm: Kr,
+  hasOwnProperty: ze,
+  hasOwnProp: ze,
+  // an alias to avoid ESLint no-prototype-builtins detection
+  reduceDescriptors: St,
+  freezeMethods: Xr,
+  toObjectSet: Zr,
+  toCamelCase: Yr,
+  noop: Qr,
+  toFiniteNumber: en,
+  findKey: yt,
+  global: z,
+  isContextDefined: wt,
+  isSpecCompliantForm: tn,
+  toJSONObject: rn,
+  isAsyncFn: nn,
+  isThenable: sn,
+  setImmediate: Et,
+  asap: an,
+  isIterable: on
+};
+function S(t, e, r, n, s) {
+  Error.call(this), Error.captureStackTrace ? Error.captureStackTrace(this, this.constructor) : this.stack = new Error().stack, this.message = t, this.name = "AxiosError", e && (this.code = e), r && (this.config = r), n && (this.request = n), s && (this.response = s, this.status = s.status ? s.status : null);
+}
+l.inherits(S, Error, {
+  toJSON: function() {
+    return {
+      // Standard
+      message: this.message,
+      name: this.name,
+      // Microsoft
+      description: this.description,
+      number: this.number,
+      // Mozilla
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      // Axios
+      config: l.toJSONObject(this.config),
+      code: this.code,
+      status: this.status
+    };
+  }
+});
+const Tt = S.prototype, vt = {};
+[
+  "ERR_BAD_OPTION_VALUE",
+  "ERR_BAD_OPTION",
+  "ECONNABORTED",
+  "ETIMEDOUT",
+  "ERR_NETWORK",
+  "ERR_FR_TOO_MANY_REDIRECTS",
+  "ERR_DEPRECATED",
+  "ERR_BAD_RESPONSE",
+  "ERR_BAD_REQUEST",
+  "ERR_CANCELED",
+  "ERR_NOT_SUPPORT",
+  "ERR_INVALID_URL"
+  // eslint-disable-next-line func-names
+].forEach((t) => {
+  vt[t] = { value: t };
+});
+Object.defineProperties(S, vt);
+Object.defineProperty(Tt, "isAxiosError", { value: !0 });
+S.from = (t, e, r, n, s, i) => {
+  const a = Object.create(Tt);
+  return l.toFlatObject(t, a, function(u) {
+    return u !== Error.prototype;
+  }, (o) => o !== "isAxiosError"), S.call(a, t.message, e, r, n, s), a.cause = t, a.name = t.name, i && Object.assign(a, i), a;
+};
+const ln = null;
+function Fe(t) {
+  return l.isPlainObject(t) || l.isArray(t);
+}
+function At(t) {
+  return l.endsWith(t, "[]") ? t.slice(0, -2) : t;
+}
+function He(t, e, r) {
+  return t ? t.concat(e).map(function(s, i) {
+    return s = At(s), !r && i ? "[" + s + "]" : s;
+  }).join(r ? "." : "") : e;
+}
+function un(t) {
+  return l.isArray(t) && !t.some(Fe);
+}
+const cn = l.toFlatObject(l, {}, null, function(e) {
+  return /^is[A-Z]/.test(e);
+});
+function ye(t, e, r) {
+  if (!l.isObject(t))
+    throw new TypeError("target must be an object");
+  e = e || new FormData(), r = l.toFlatObject(r, {
+    metaTokens: !0,
+    dots: !1,
+    indexes: !1
+  }, !1, function(g, m) {
+    return !l.isUndefined(m[g]);
+  });
+  const n = r.metaTokens, s = r.visitor || f, i = r.dots, a = r.indexes, u = (r.Blob || typeof Blob < "u" && Blob) && l.isSpecCompliantForm(e);
+  if (!l.isFunction(s))
+    throw new TypeError("visitor must be a function");
+  function c(p) {
+    if (p === null) return "";
+    if (l.isDate(p))
+      return p.toISOString();
+    if (l.isBoolean(p))
+      return p.toString();
+    if (!u && l.isBlob(p))
+      throw new S("Blob is not supported. Use a Buffer instead.");
+    return l.isArrayBuffer(p) || l.isTypedArray(p) ? u && typeof Blob == "function" ? new Blob([p]) : Buffer.from(p) : p;
+  }
+  function f(p, g, m) {
+    let d = p;
+    if (p && !m && typeof p == "object") {
+      if (l.endsWith(g, "{}"))
+        g = n ? g : g.slice(0, -2), p = JSON.stringify(p);
+      else if (l.isArray(p) && un(p) || (l.isFileList(p) || l.endsWith(g, "[]")) && (d = l.toArray(p)))
+        return g = At(g), d.forEach(function(E, O) {
+          !(l.isUndefined(E) || E === null) && e.append(
+            // eslint-disable-next-line no-nested-ternary
+            a === !0 ? He([g], O, i) : a === null ? g : g + "[]",
+            c(E)
+          );
+        }), !1;
+    }
+    return Fe(p) ? !0 : (e.append(He(m, g, i), c(p)), !1);
+  }
+  const h = [], y = Object.assign(cn, {
+    defaultVisitor: f,
+    convertValue: c,
+    isVisitable: Fe
+  });
+  function w(p, g) {
+    if (!l.isUndefined(p)) {
+      if (h.indexOf(p) !== -1)
+        throw Error("Circular reference detected in " + g.join("."));
+      h.push(p), l.forEach(p, function(d, b) {
+        (!(l.isUndefined(d) || d === null) && s.call(
+          e,
+          d,
+          l.isString(b) ? b.trim() : b,
+          g,
+          y
+        )) === !0 && w(d, g ? g.concat(b) : [b]);
+      }), h.pop();
+    }
+  }
+  if (!l.isObject(t))
+    throw new TypeError("data must be an object");
+  return w(t), e;
+}
+function Ve(t) {
+  const e = {
+    "!": "%21",
+    "'": "%27",
+    "(": "%28",
+    ")": "%29",
+    "~": "%7E",
+    "%20": "+",
+    "%00": "\0"
+  };
+  return encodeURIComponent(t).replace(/[!'()~]|%20|%00/g, function(n) {
+    return e[n];
+  });
+}
+function $e(t, e) {
+  this._pairs = [], t && ye(t, this, e);
+}
+const Ot = $e.prototype;
+Ot.append = function(e, r) {
+  this._pairs.push([e, r]);
+};
+Ot.toString = function(e) {
+  const r = e ? function(n) {
+    return e.call(this, n, Ve);
+  } : Ve;
+  return this._pairs.map(function(s) {
+    return r(s[0]) + "=" + r(s[1]);
+  }, "").join("&");
+};
+function fn(t) {
+  return encodeURIComponent(t).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+}
+function xt(t, e, r) {
+  if (!e)
+    return t;
+  const n = r && r.encode || fn;
+  l.isFunction(r) && (r = {
+    serialize: r
+  });
+  const s = r && r.serialize;
+  let i;
+  if (s ? i = s(e, r) : i = l.isURLSearchParams(e) ? e.toString() : new $e(e, r).toString(n), i) {
+    const a = t.indexOf("#");
+    a !== -1 && (t = t.slice(0, a)), t += (t.indexOf("?") === -1 ? "?" : "&") + i;
+  }
+  return t;
+}
+class Ge {
+  constructor() {
+    this.handlers = [];
+  }
+  /**
+   * Add a new interceptor to the stack
+   *
+   * @param {Function} fulfilled The function to handle `then` for a `Promise`
+   * @param {Function} rejected The function to handle `reject` for a `Promise`
+   *
+   * @return {Number} An ID used to remove interceptor later
+   */
+  use(e, r, n) {
+    return this.handlers.push({
+      fulfilled: e,
+      rejected: r,
+      synchronous: n ? n.synchronous : !1,
+      runWhen: n ? n.runWhen : null
+    }), this.handlers.length - 1;
+  }
+  /**
+   * Remove an interceptor from the stack
+   *
+   * @param {Number} id The ID that was returned by `use`
+   *
+   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
+   */
+  eject(e) {
+    this.handlers[e] && (this.handlers[e] = null);
+  }
+  /**
+   * Clear all interceptors from the stack
+   *
+   * @returns {void}
+   */
+  clear() {
+    this.handlers && (this.handlers = []);
+  }
+  /**
+   * Iterate over all the registered interceptors
+   *
+   * This method is particularly useful for skipping over any
+   * interceptors that may have become `null` calling `eject`.
+   *
+   * @param {Function} fn The function to call for each interceptor
+   *
+   * @returns {void}
+   */
+  forEach(e) {
+    l.forEach(this.handlers, function(n) {
+      n !== null && e(n);
+    });
+  }
+}
+const Rt = {
+  silentJSONParsing: !0,
+  forcedJSONParsing: !0,
+  clarifyTimeoutError: !1
+}, hn = typeof URLSearchParams < "u" ? URLSearchParams : $e, dn = typeof FormData < "u" ? FormData : null, pn = typeof Blob < "u" ? Blob : null, mn = {
+  isBrowser: !0,
+  classes: {
+    URLSearchParams: hn,
+    FormData: dn,
+    Blob: pn
+  },
+  protocols: ["http", "https", "file", "blob", "url", "data"]
+}, Be = typeof window < "u" && typeof document < "u", De = typeof navigator == "object" && navigator || void 0, gn = Be && (!De || ["ReactNative", "NativeScript", "NS"].indexOf(De.product) < 0), bn = typeof WorkerGlobalScope < "u" && // eslint-disable-next-line no-undef
+self instanceof WorkerGlobalScope && typeof self.importScripts == "function", yn = Be && window.location.href || "http://localhost", wn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  hasBrowserEnv: Be,
+  hasStandardBrowserEnv: gn,
+  hasStandardBrowserWebWorkerEnv: bn,
+  navigator: De,
+  origin: yn
+}, Symbol.toStringTag, { value: "Module" })), F = {
+  ...wn,
+  ...mn
+};
+function Sn(t, e) {
+  return ye(t, new F.classes.URLSearchParams(), {
+    visitor: function(r, n, s, i) {
+      return F.isNode && l.isBuffer(r) ? (this.append(n, r.toString("base64")), !1) : i.defaultVisitor.apply(this, arguments);
+    },
+    ...e
+  });
+}
+function En(t) {
+  return l.matchAll(/\w+|\[(\w*)]/g, t).map((e) => e[0] === "[]" ? "" : e[1] || e[0]);
+}
+function Tn(t) {
+  const e = {}, r = Object.keys(t);
+  let n;
+  const s = r.length;
+  let i;
+  for (n = 0; n < s; n++)
+    i = r[n], e[i] = t[i];
+  return e;
+}
+function Ft(t) {
+  function e(r, n, s, i) {
+    let a = r[i++];
+    if (a === "__proto__") return !0;
+    const o = Number.isFinite(+a), u = i >= r.length;
+    return a = !a && l.isArray(s) ? s.length : a, u ? (l.hasOwnProp(s, a) ? s[a] = [s[a], n] : s[a] = n, !o) : ((!s[a] || !l.isObject(s[a])) && (s[a] = []), e(r, n, s[a], i) && l.isArray(s[a]) && (s[a] = Tn(s[a])), !o);
+  }
+  if (l.isFormData(t) && l.isFunction(t.entries)) {
+    const r = {};
+    return l.forEachEntry(t, (n, s) => {
+      e(En(n), s, r, 0);
+    }), r;
+  }
+  return null;
+}
+function vn(t, e, r) {
+  if (l.isString(t))
+    try {
+      return (e || JSON.parse)(t), l.trim(t);
+    } catch (n) {
+      if (n.name !== "SyntaxError")
+        throw n;
+    }
+  return (r || JSON.stringify)(t);
+}
+const ne = {
+  transitional: Rt,
+  adapter: ["xhr", "http", "fetch"],
+  transformRequest: [function(e, r) {
+    const n = r.getContentType() || "", s = n.indexOf("application/json") > -1, i = l.isObject(e);
+    if (i && l.isHTMLForm(e) && (e = new FormData(e)), l.isFormData(e))
+      return s ? JSON.stringify(Ft(e)) : e;
+    if (l.isArrayBuffer(e) || l.isBuffer(e) || l.isStream(e) || l.isFile(e) || l.isBlob(e) || l.isReadableStream(e))
+      return e;
+    if (l.isArrayBufferView(e))
+      return e.buffer;
+    if (l.isURLSearchParams(e))
+      return r.setContentType("application/x-www-form-urlencoded;charset=utf-8", !1), e.toString();
+    let o;
+    if (i) {
+      if (n.indexOf("application/x-www-form-urlencoded") > -1)
+        return Sn(e, this.formSerializer).toString();
+      if ((o = l.isFileList(e)) || n.indexOf("multipart/form-data") > -1) {
+        const u = this.env && this.env.FormData;
+        return ye(
+          o ? { "files[]": e } : e,
+          u && new u(),
+          this.formSerializer
+        );
+      }
+    }
+    return i || s ? (r.setContentType("application/json", !1), vn(e)) : e;
+  }],
+  transformResponse: [function(e) {
+    const r = this.transitional || ne.transitional, n = r && r.forcedJSONParsing, s = this.responseType === "json";
+    if (l.isResponse(e) || l.isReadableStream(e))
+      return e;
+    if (e && l.isString(e) && (n && !this.responseType || s)) {
+      const a = !(r && r.silentJSONParsing) && s;
+      try {
+        return JSON.parse(e);
+      } catch (o) {
+        if (a)
+          throw o.name === "SyntaxError" ? S.from(o, S.ERR_BAD_RESPONSE, this, null, this.response) : o;
+      }
+    }
+    return e;
+  }],
+  /**
+   * A timeout in milliseconds to abort a request. If set to 0 (default) a
+   * timeout is not created.
+   */
+  timeout: 0,
+  xsrfCookieName: "XSRF-TOKEN",
+  xsrfHeaderName: "X-XSRF-TOKEN",
+  maxContentLength: -1,
+  maxBodyLength: -1,
+  env: {
+    FormData: F.classes.FormData,
+    Blob: F.classes.Blob
+  },
+  validateStatus: function(e) {
+    return e >= 200 && e < 300;
+  },
+  headers: {
+    common: {
+      Accept: "application/json, text/plain, */*",
+      "Content-Type": void 0
+    }
+  }
+};
+l.forEach(["delete", "get", "head", "post", "put", "patch"], (t) => {
+  ne.headers[t] = {};
+});
+const An = l.toObjectSet([
+  "age",
+  "authorization",
+  "content-length",
+  "content-type",
+  "etag",
+  "expires",
+  "from",
+  "host",
+  "if-modified-since",
+  "if-unmodified-since",
+  "last-modified",
+  "location",
+  "max-forwards",
+  "proxy-authorization",
+  "referer",
+  "retry-after",
+  "user-agent"
+]), On = (t) => {
+  const e = {};
+  let r, n, s;
+  return t && t.split(`
+`).forEach(function(a) {
+    s = a.indexOf(":"), r = a.substring(0, s).trim().toLowerCase(), n = a.substring(s + 1).trim(), !(!r || e[r] && An[r]) && (r === "set-cookie" ? e[r] ? e[r].push(n) : e[r] = [n] : e[r] = e[r] ? e[r] + ", " + n : n);
+  }), e;
+}, Je = Symbol("internals");
+function X(t) {
+  return t && String(t).trim().toLowerCase();
+}
+function ue(t) {
+  return t === !1 || t == null ? t : l.isArray(t) ? t.map(ue) : String(t);
+}
+function xn(t) {
+  const e = /* @__PURE__ */ Object.create(null), r = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
+  let n;
+  for (; n = r.exec(t); )
+    e[n[1]] = n[2];
+  return e;
+}
+const Rn = (t) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(t.trim());
+function Te(t, e, r, n, s) {
+  if (l.isFunction(n))
+    return n.call(this, e, r);
+  if (s && (e = r), !!l.isString(e)) {
+    if (l.isString(n))
+      return e.indexOf(n) !== -1;
+    if (l.isRegExp(n))
+      return n.test(e);
+  }
+}
+function Fn(t) {
+  return t.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (e, r, n) => r.toUpperCase() + n);
+}
+function Dn(t, e) {
+  const r = l.toCamelCase(" " + e);
+  ["get", "set", "has"].forEach((n) => {
+    Object.defineProperty(t, n + r, {
+      value: function(s, i, a) {
+        return this[n].call(this, e, s, i, a);
+      },
+      configurable: !0
+    });
+  });
+}
+let P = class {
+  constructor(e) {
+    e && this.set(e);
+  }
+  set(e, r, n) {
+    const s = this;
+    function i(o, u, c) {
+      const f = X(u);
+      if (!f)
+        throw new Error("header name must be a non-empty string");
+      const h = l.findKey(s, f);
+      (!h || s[h] === void 0 || c === !0 || c === void 0 && s[h] !== !1) && (s[h || u] = ue(o));
+    }
+    const a = (o, u) => l.forEach(o, (c, f) => i(c, f, u));
+    if (l.isPlainObject(e) || e instanceof this.constructor)
+      a(e, r);
+    else if (l.isString(e) && (e = e.trim()) && !Rn(e))
+      a(On(e), r);
+    else if (l.isObject(e) && l.isIterable(e)) {
+      let o = {}, u, c;
+      for (const f of e) {
+        if (!l.isArray(f))
+          throw TypeError("Object iterator must return a key-value pair");
+        o[c = f[0]] = (u = o[c]) ? l.isArray(u) ? [...u, f[1]] : [u, f[1]] : f[1];
+      }
+      a(o, r);
+    } else
+      e != null && i(r, e, n);
+    return this;
+  }
+  get(e, r) {
+    if (e = X(e), e) {
+      const n = l.findKey(this, e);
+      if (n) {
+        const s = this[n];
+        if (!r)
+          return s;
+        if (r === !0)
+          return xn(s);
+        if (l.isFunction(r))
+          return r.call(this, s, n);
+        if (l.isRegExp(r))
+          return r.exec(s);
+        throw new TypeError("parser must be boolean|regexp|function");
+      }
+    }
+  }
+  has(e, r) {
+    if (e = X(e), e) {
+      const n = l.findKey(this, e);
+      return !!(n && this[n] !== void 0 && (!r || Te(this, this[n], n, r)));
+    }
+    return !1;
+  }
+  delete(e, r) {
+    const n = this;
+    let s = !1;
+    function i(a) {
+      if (a = X(a), a) {
+        const o = l.findKey(n, a);
+        o && (!r || Te(n, n[o], o, r)) && (delete n[o], s = !0);
+      }
+    }
+    return l.isArray(e) ? e.forEach(i) : i(e), s;
+  }
+  clear(e) {
+    const r = Object.keys(this);
+    let n = r.length, s = !1;
+    for (; n--; ) {
+      const i = r[n];
+      (!e || Te(this, this[i], i, e, !0)) && (delete this[i], s = !0);
+    }
+    return s;
+  }
+  normalize(e) {
+    const r = this, n = {};
+    return l.forEach(this, (s, i) => {
+      const a = l.findKey(n, i);
+      if (a) {
+        r[a] = ue(s), delete r[i];
+        return;
+      }
+      const o = e ? Fn(i) : String(i).trim();
+      o !== i && delete r[i], r[o] = ue(s), n[o] = !0;
+    }), this;
+  }
+  concat(...e) {
+    return this.constructor.concat(this, ...e);
+  }
+  toJSON(e) {
+    const r = /* @__PURE__ */ Object.create(null);
+    return l.forEach(this, (n, s) => {
+      n != null && n !== !1 && (r[s] = e && l.isArray(n) ? n.join(", ") : n);
+    }), r;
+  }
+  [Symbol.iterator]() {
+    return Object.entries(this.toJSON())[Symbol.iterator]();
+  }
+  toString() {
+    return Object.entries(this.toJSON()).map(([e, r]) => e + ": " + r).join(`
+`);
+  }
+  getSetCookie() {
+    return this.get("set-cookie") || [];
+  }
+  get [Symbol.toStringTag]() {
+    return "AxiosHeaders";
+  }
+  static from(e) {
+    return e instanceof this ? e : new this(e);
+  }
+  static concat(e, ...r) {
+    const n = new this(e);
+    return r.forEach((s) => n.set(s)), n;
+  }
+  static accessor(e) {
+    const n = (this[Je] = this[Je] = {
+      accessors: {}
+    }).accessors, s = this.prototype;
+    function i(a) {
+      const o = X(a);
+      n[o] || (Dn(s, a), n[o] = !0);
+    }
+    return l.isArray(e) ? e.forEach(i) : i(e), this;
+  }
+};
+P.accessor(["Content-Type", "Content-Length", "Accept", "Accept-Encoding", "User-Agent", "Authorization"]);
+l.reduceDescriptors(P.prototype, ({ value: t }, e) => {
+  let r = e[0].toUpperCase() + e.slice(1);
+  return {
+    get: () => t,
+    set(n) {
+      this[r] = n;
+    }
+  };
+});
+l.freezeMethods(P);
+function ve(t, e) {
+  const r = this || ne, n = e || r, s = P.from(n.headers);
+  let i = n.data;
+  return l.forEach(t, function(o) {
+    i = o.call(r, i, s.normalize(), e ? e.status : void 0);
+  }), s.normalize(), i;
+}
+function Dt(t) {
+  return !!(t && t.__CANCEL__);
+}
+function Y(t, e, r) {
+  S.call(this, t ?? "canceled", S.ERR_CANCELED, e, r), this.name = "CanceledError";
+}
+l.inherits(Y, S, {
+  __CANCEL__: !0
+});
+function _t(t, e, r) {
+  const n = r.config.validateStatus;
+  !r.status || !n || n(r.status) ? t(r) : e(new S(
+    "Request failed with status code " + r.status,
+    [S.ERR_BAD_REQUEST, S.ERR_BAD_RESPONSE][Math.floor(r.status / 100) - 4],
+    r.config,
+    r.request,
+    r
+  ));
+}
+function _n(t) {
+  const e = /^([-+\w]{1,25})(:?\/\/|:)/.exec(t);
+  return e && e[1] || "";
+}
+function Nn(t, e) {
+  t = t || 10;
+  const r = new Array(t), n = new Array(t);
+  let s = 0, i = 0, a;
+  return e = e !== void 0 ? e : 1e3, function(u) {
+    const c = Date.now(), f = n[i];
+    a || (a = c), r[s] = u, n[s] = c;
+    let h = i, y = 0;
+    for (; h !== s; )
+      y += r[h++], h = h % t;
+    if (s = (s + 1) % t, s === i && (i = (i + 1) % t), c - a < e)
+      return;
+    const w = f && c - f;
+    return w ? Math.round(y * 1e3 / w) : void 0;
+  };
+}
+function Pn(t, e) {
+  let r = 0, n = 1e3 / e, s, i;
+  const a = (c, f = Date.now()) => {
+    r = f, s = null, i && (clearTimeout(i), i = null), t(...c);
+  };
+  return [(...c) => {
+    const f = Date.now(), h = f - r;
+    h >= n ? a(c, f) : (s = c, i || (i = setTimeout(() => {
+      i = null, a(s);
+    }, n - h)));
+  }, () => s && a(s)];
+}
+const de = (t, e, r = 3) => {
+  let n = 0;
+  const s = Nn(50, 250);
+  return Pn((i) => {
+    const a = i.loaded, o = i.lengthComputable ? i.total : void 0, u = a - n, c = s(u), f = a <= o;
+    n = a;
+    const h = {
+      loaded: a,
+      total: o,
+      progress: o ? a / o : void 0,
+      bytes: u,
+      rate: c || void 0,
+      estimated: c && o && f ? (o - a) / c : void 0,
+      event: i,
+      lengthComputable: o != null,
+      [e ? "download" : "upload"]: !0
+    };
+    t(h);
+  }, r);
+}, Ke = (t, e) => {
+  const r = t != null;
+  return [(n) => e[0]({
+    lengthComputable: r,
+    total: t,
+    loaded: n
+  }), e[1]];
+}, Ye = (t) => (...e) => l.asap(() => t(...e)), Cn = F.hasStandardBrowserEnv ? /* @__PURE__ */ ((t, e) => (r) => (r = new URL(r, F.origin), t.protocol === r.protocol && t.host === r.host && (e || t.port === r.port)))(
+  new URL(F.origin),
+  F.navigator && /(msie|trident)/i.test(F.navigator.userAgent)
+) : () => !0, kn = F.hasStandardBrowserEnv ? (
+  // Standard browser envs support document.cookie
+  {
+    write(t, e, r, n, s, i) {
+      const a = [t + "=" + encodeURIComponent(e)];
+      l.isNumber(r) && a.push("expires=" + new Date(r).toGMTString()), l.isString(n) && a.push("path=" + n), l.isString(s) && a.push("domain=" + s), i === !0 && a.push("secure"), document.cookie = a.join("; ");
+    },
+    read(t) {
+      const e = document.cookie.match(new RegExp("(^|;\\s*)(" + t + ")=([^;]*)"));
+      return e ? decodeURIComponent(e[3]) : null;
+    },
+    remove(t) {
+      this.write(t, "", Date.now() - 864e5);
+    }
+  }
+) : (
+  // Non-standard browser env (web workers, react-native) lack needed support.
+  {
+    write() {
+    },
+    read() {
+      return null;
+    },
+    remove() {
+    }
+  }
+);
+function $n(t) {
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(t);
+}
+function Bn(t, e) {
+  return e ? t.replace(/\/?\/$/, "") + "/" + e.replace(/^\/+/, "") : t;
+}
+function Nt(t, e, r) {
+  let n = !$n(e);
+  return t && (n || r == !1) ? Bn(t, e) : e;
+}
+const We = (t) => t instanceof P ? { ...t } : t;
+function V(t, e) {
+  e = e || {};
+  const r = {};
+  function n(c, f, h, y) {
+    return l.isPlainObject(c) && l.isPlainObject(f) ? l.merge.call({ caseless: y }, c, f) : l.isPlainObject(f) ? l.merge({}, f) : l.isArray(f) ? f.slice() : f;
+  }
+  function s(c, f, h, y) {
+    if (l.isUndefined(f)) {
+      if (!l.isUndefined(c))
+        return n(void 0, c, h, y);
+    } else return n(c, f, h, y);
+  }
+  function i(c, f) {
+    if (!l.isUndefined(f))
+      return n(void 0, f);
+  }
+  function a(c, f) {
+    if (l.isUndefined(f)) {
+      if (!l.isUndefined(c))
+        return n(void 0, c);
+    } else return n(void 0, f);
+  }
+  function o(c, f, h) {
+    if (h in e)
+      return n(c, f);
+    if (h in t)
+      return n(void 0, c);
+  }
+  const u = {
+    url: i,
+    method: i,
+    data: i,
+    baseURL: a,
+    transformRequest: a,
+    transformResponse: a,
+    paramsSerializer: a,
+    timeout: a,
+    timeoutMessage: a,
+    withCredentials: a,
+    withXSRFToken: a,
+    adapter: a,
+    responseType: a,
+    xsrfCookieName: a,
+    xsrfHeaderName: a,
+    onUploadProgress: a,
+    onDownloadProgress: a,
+    decompress: a,
+    maxContentLength: a,
+    maxBodyLength: a,
+    beforeRedirect: a,
+    transport: a,
+    httpAgent: a,
+    httpsAgent: a,
+    cancelToken: a,
+    socketPath: a,
+    responseEncoding: a,
+    validateStatus: o,
+    headers: (c, f, h) => s(We(c), We(f), h, !0)
+  };
+  return l.forEach(Object.keys({ ...t, ...e }), function(f) {
+    const h = u[f] || s, y = h(t[f], e[f], f);
+    l.isUndefined(y) && h !== o || (r[f] = y);
+  }), r;
+}
+const Pt = (t) => {
+  const e = V({}, t);
+  let { data: r, withXSRFToken: n, xsrfHeaderName: s, xsrfCookieName: i, headers: a, auth: o } = e;
+  e.headers = a = P.from(a), e.url = xt(Nt(e.baseURL, e.url, e.allowAbsoluteUrls), t.params, t.paramsSerializer), o && a.set(
+    "Authorization",
+    "Basic " + btoa((o.username || "") + ":" + (o.password ? unescape(encodeURIComponent(o.password)) : ""))
+  );
+  let u;
+  if (l.isFormData(r)) {
+    if (F.hasStandardBrowserEnv || F.hasStandardBrowserWebWorkerEnv)
+      a.setContentType(void 0);
+    else if ((u = a.getContentType()) !== !1) {
+      const [c, ...f] = u ? u.split(";").map((h) => h.trim()).filter(Boolean) : [];
+      a.setContentType([c || "multipart/form-data", ...f].join("; "));
+    }
+  }
+  if (F.hasStandardBrowserEnv && (n && l.isFunction(n) && (n = n(e)), n || n !== !1 && Cn(e.url))) {
+    const c = s && i && kn.read(i);
+    c && a.set(s, c);
+  }
+  return e;
+}, Mn = typeof XMLHttpRequest < "u", jn = Mn && function(t) {
+  return new Promise(function(r, n) {
+    const s = Pt(t);
+    let i = s.data;
+    const a = P.from(s.headers).normalize();
+    let { responseType: o, onUploadProgress: u, onDownloadProgress: c } = s, f, h, y, w, p;
+    function g() {
+      w && w(), p && p(), s.cancelToken && s.cancelToken.unsubscribe(f), s.signal && s.signal.removeEventListener("abort", f);
+    }
+    let m = new XMLHttpRequest();
+    m.open(s.method.toUpperCase(), s.url, !0), m.timeout = s.timeout;
+    function d() {
+      if (!m)
+        return;
+      const E = P.from(
+        "getAllResponseHeaders" in m && m.getAllResponseHeaders()
+      ), T = {
+        data: !o || o === "text" || o === "json" ? m.responseText : m.response,
+        status: m.status,
+        statusText: m.statusText,
+        headers: E,
+        config: t,
+        request: m
+      };
+      _t(function(x) {
+        r(x), g();
+      }, function(x) {
+        n(x), g();
+      }, T), m = null;
+    }
+    "onloadend" in m ? m.onloadend = d : m.onreadystatechange = function() {
+      !m || m.readyState !== 4 || m.status === 0 && !(m.responseURL && m.responseURL.indexOf("file:") === 0) || setTimeout(d);
+    }, m.onabort = function() {
+      m && (n(new S("Request aborted", S.ECONNABORTED, t, m)), m = null);
+    }, m.onerror = function() {
+      n(new S("Network Error", S.ERR_NETWORK, t, m)), m = null;
+    }, m.ontimeout = function() {
+      let O = s.timeout ? "timeout of " + s.timeout + "ms exceeded" : "timeout exceeded";
+      const T = s.transitional || Rt;
+      s.timeoutErrorMessage && (O = s.timeoutErrorMessage), n(new S(
+        O,
+        T.clarifyTimeoutError ? S.ETIMEDOUT : S.ECONNABORTED,
+        t,
+        m
+      )), m = null;
+    }, i === void 0 && a.setContentType(null), "setRequestHeader" in m && l.forEach(a.toJSON(), function(O, T) {
+      m.setRequestHeader(T, O);
+    }), l.isUndefined(s.withCredentials) || (m.withCredentials = !!s.withCredentials), o && o !== "json" && (m.responseType = s.responseType), c && ([y, p] = de(c, !0), m.addEventListener("progress", y)), u && m.upload && ([h, w] = de(u), m.upload.addEventListener("progress", h), m.upload.addEventListener("loadend", w)), (s.cancelToken || s.signal) && (f = (E) => {
+      m && (n(!E || E.type ? new Y(null, t, m) : E), m.abort(), m = null);
+    }, s.cancelToken && s.cancelToken.subscribe(f), s.signal && (s.signal.aborted ? f() : s.signal.addEventListener("abort", f)));
+    const b = _n(s.url);
+    if (b && F.protocols.indexOf(b) === -1) {
+      n(new S("Unsupported protocol " + b + ":", S.ERR_BAD_REQUEST, t));
+      return;
+    }
+    m.send(i || null);
+  });
+}, In = (t, e) => {
+  const { length: r } = t = t ? t.filter(Boolean) : [];
+  if (e || r) {
+    let n = new AbortController(), s;
+    const i = function(c) {
+      if (!s) {
+        s = !0, o();
+        const f = c instanceof Error ? c : this.reason;
+        n.abort(f instanceof S ? f : new Y(f instanceof Error ? f.message : f));
+      }
+    };
+    let a = e && setTimeout(() => {
+      a = null, i(new S(`timeout ${e} of ms exceeded`, S.ETIMEDOUT));
+    }, e);
+    const o = () => {
+      t && (a && clearTimeout(a), a = null, t.forEach((c) => {
+        c.unsubscribe ? c.unsubscribe(i) : c.removeEventListener("abort", i);
+      }), t = null);
+    };
+    t.forEach((c) => c.addEventListener("abort", i));
+    const { signal: u } = n;
+    return u.unsubscribe = () => l.asap(o), u;
+  }
+}, Ln = function* (t, e) {
+  let r = t.byteLength;
+  if (r < e) {
+    yield t;
+    return;
+  }
+  let n = 0, s;
+  for (; n < r; )
+    s = n + e, yield t.slice(n, s), n = s;
+}, Un = async function* (t, e) {
+  for await (const r of qn(t))
+    yield* Ln(r, e);
+}, qn = async function* (t) {
+  if (t[Symbol.asyncIterator]) {
+    yield* t;
+    return;
+  }
+  const e = t.getReader();
+  try {
+    for (; ; ) {
+      const { done: r, value: n } = await e.read();
+      if (r)
+        break;
+      yield n;
+    }
+  } finally {
+    await e.cancel();
+  }
+}, Xe = (t, e, r, n) => {
+  const s = Un(t, e);
+  let i = 0, a, o = (u) => {
+    a || (a = !0, n && n(u));
+  };
+  return new ReadableStream({
+    async pull(u) {
+      try {
+        const { done: c, value: f } = await s.next();
+        if (c) {
+          o(), u.close();
+          return;
+        }
+        let h = f.byteLength;
+        if (r) {
+          let y = i += h;
+          r(y);
+        }
+        u.enqueue(new Uint8Array(f));
+      } catch (c) {
+        throw o(c), c;
+      }
+    },
+    cancel(u) {
+      return o(u), s.return();
+    }
+  }, {
+    highWaterMark: 2
+  });
+}, we = typeof fetch == "function" && typeof Request == "function" && typeof Response == "function", Ct = we && typeof ReadableStream == "function", zn = we && (typeof TextEncoder == "function" ? /* @__PURE__ */ ((t) => (e) => t.encode(e))(new TextEncoder()) : async (t) => new Uint8Array(await new Response(t).arrayBuffer())), kt = (t, ...e) => {
+  try {
+    return !!t(...e);
+  } catch {
+    return !1;
+  }
+}, Hn = Ct && kt(() => {
+  let t = !1;
+  const e = new Request(F.origin, {
+    body: new ReadableStream(),
+    method: "POST",
+    get duplex() {
+      return t = !0, "half";
+    }
+  }).headers.has("Content-Type");
+  return t && !e;
+}), Ze = 64 * 1024, _e = Ct && kt(() => l.isReadableStream(new Response("").body)), pe = {
+  stream: _e && ((t) => t.body)
+};
+we && ((t) => {
+  ["text", "arrayBuffer", "blob", "formData", "stream"].forEach((e) => {
+    !pe[e] && (pe[e] = l.isFunction(t[e]) ? (r) => r[e]() : (r, n) => {
+      throw new S(`Response type '${e}' is not supported`, S.ERR_NOT_SUPPORT, n);
+    });
+  });
+})(new Response());
+const Vn = async (t) => {
+  if (t == null)
+    return 0;
+  if (l.isBlob(t))
+    return t.size;
+  if (l.isSpecCompliantForm(t))
+    return (await new Request(F.origin, {
+      method: "POST",
+      body: t
+    }).arrayBuffer()).byteLength;
+  if (l.isArrayBufferView(t) || l.isArrayBuffer(t))
+    return t.byteLength;
+  if (l.isURLSearchParams(t) && (t = t + ""), l.isString(t))
+    return (await zn(t)).byteLength;
+}, Gn = async (t, e) => {
+  const r = l.toFiniteNumber(t.getContentLength());
+  return r ?? Vn(e);
+}, Jn = we && (async (t) => {
+  let {
+    url: e,
+    method: r,
+    data: n,
+    signal: s,
+    cancelToken: i,
+    timeout: a,
+    onDownloadProgress: o,
+    onUploadProgress: u,
+    responseType: c,
+    headers: f,
+    withCredentials: h = "same-origin",
+    fetchOptions: y
+  } = Pt(t);
+  c = c ? (c + "").toLowerCase() : "text";
+  let w = In([s, i && i.toAbortSignal()], a), p;
+  const g = w && w.unsubscribe && (() => {
+    w.unsubscribe();
+  });
+  let m;
+  try {
+    if (u && Hn && r !== "get" && r !== "head" && (m = await Gn(f, n)) !== 0) {
+      let T = new Request(e, {
+        method: "POST",
+        body: n,
+        duplex: "half"
+      }), v;
+      if (l.isFormData(n) && (v = T.headers.get("content-type")) && f.setContentType(v), T.body) {
+        const [x, C] = Ke(
+          m,
+          de(Ye(u))
+        );
+        n = Xe(T.body, Ze, x, C);
+      }
+    }
+    l.isString(h) || (h = h ? "include" : "omit");
+    const d = "credentials" in Request.prototype;
+    p = new Request(e, {
+      ...y,
+      signal: w,
+      method: r.toUpperCase(),
+      headers: f.normalize().toJSON(),
+      body: n,
+      duplex: "half",
+      credentials: d ? h : void 0
+    });
+    let b = await fetch(p, y);
+    const E = _e && (c === "stream" || c === "response");
+    if (_e && (o || E && g)) {
+      const T = {};
+      ["status", "statusText", "headers"].forEach((k) => {
+        T[k] = b[k];
+      });
+      const v = l.toFiniteNumber(b.headers.get("content-length")), [x, C] = o && Ke(
+        v,
+        de(Ye(o), !0)
+      ) || [];
+      b = new Response(
+        Xe(b.body, Ze, x, () => {
+          C && C(), g && g();
+        }),
+        T
+      );
+    }
+    c = c || "text";
+    let O = await pe[l.findKey(pe, c) || "text"](b, t);
+    return !E && g && g(), await new Promise((T, v) => {
+      _t(T, v, {
+        data: O,
+        headers: P.from(b.headers),
+        status: b.status,
+        statusText: b.statusText,
+        config: t,
+        request: p
+      });
+    });
+  } catch (d) {
+    throw g && g(), d && d.name === "TypeError" && /Load failed|fetch/i.test(d.message) ? Object.assign(
+      new S("Network Error", S.ERR_NETWORK, t, p),
+      {
+        cause: d.cause || d
+      }
+    ) : S.from(d, d && d.code, t, p);
+  }
+}), Ne = {
+  http: ln,
+  xhr: jn,
+  fetch: Jn
+};
+l.forEach(Ne, (t, e) => {
+  if (t) {
+    try {
+      Object.defineProperty(t, "name", { value: e });
+    } catch {
+    }
+    Object.defineProperty(t, "adapterName", { value: e });
+  }
+});
+const Qe = (t) => `- ${t}`, Kn = (t) => l.isFunction(t) || t === null || t === !1, $t = {
+  getAdapter: (t) => {
+    t = l.isArray(t) ? t : [t];
+    const { length: e } = t;
+    let r, n;
+    const s = {};
+    for (let i = 0; i < e; i++) {
+      r = t[i];
+      let a;
+      if (n = r, !Kn(r) && (n = Ne[(a = String(r)).toLowerCase()], n === void 0))
+        throw new S(`Unknown adapter '${a}'`);
+      if (n)
+        break;
+      s[a || "#" + i] = n;
+    }
+    if (!n) {
+      const i = Object.entries(s).map(
+        ([o, u]) => `adapter ${o} ` + (u === !1 ? "is not supported by the environment" : "is not available in the build")
+      );
+      let a = e ? i.length > 1 ? `since :
+` + i.map(Qe).join(`
+`) : " " + Qe(i[0]) : "as no adapter specified";
+      throw new S(
+        "There is no suitable adapter to dispatch the request " + a,
+        "ERR_NOT_SUPPORT"
+      );
+    }
+    return n;
+  },
+  adapters: Ne
+};
+function Ae(t) {
+  if (t.cancelToken && t.cancelToken.throwIfRequested(), t.signal && t.signal.aborted)
+    throw new Y(null, t);
+}
+function et(t) {
+  return Ae(t), t.headers = P.from(t.headers), t.data = ve.call(
+    t,
+    t.transformRequest
+  ), ["post", "put", "patch"].indexOf(t.method) !== -1 && t.headers.setContentType("application/x-www-form-urlencoded", !1), $t.getAdapter(t.adapter || ne.adapter)(t).then(function(n) {
+    return Ae(t), n.data = ve.call(
+      t,
+      t.transformResponse,
+      n
+    ), n.headers = P.from(n.headers), n;
+  }, function(n) {
+    return Dt(n) || (Ae(t), n && n.response && (n.response.data = ve.call(
+      t,
+      t.transformResponse,
+      n.response
+    ), n.response.headers = P.from(n.response.headers))), Promise.reject(n);
+  });
+}
+const Bt = "1.11.0", Se = {};
+["object", "boolean", "number", "function", "string", "symbol"].forEach((t, e) => {
+  Se[t] = function(n) {
+    return typeof n === t || "a" + (e < 1 ? "n " : " ") + t;
+  };
+});
+const tt = {};
+Se.transitional = function(e, r, n) {
+  function s(i, a) {
+    return "[Axios v" + Bt + "] Transitional option '" + i + "'" + a + (n ? ". " + n : "");
+  }
+  return (i, a, o) => {
+    if (e === !1)
+      throw new S(
+        s(a, " has been removed" + (r ? " in " + r : "")),
+        S.ERR_DEPRECATED
+      );
+    return r && !tt[a] && (tt[a] = !0, console.warn(
+      s(
+        a,
+        " has been deprecated since v" + r + " and will be removed in the near future"
+      )
+    )), e ? e(i, a, o) : !0;
+  };
+};
+Se.spelling = function(e) {
+  return (r, n) => (console.warn(`${n} is likely a misspelling of ${e}`), !0);
+};
+function Yn(t, e, r) {
+  if (typeof t != "object")
+    throw new S("options must be an object", S.ERR_BAD_OPTION_VALUE);
+  const n = Object.keys(t);
+  let s = n.length;
+  for (; s-- > 0; ) {
+    const i = n[s], a = e[i];
+    if (a) {
+      const o = t[i], u = o === void 0 || a(o, i, t);
+      if (u !== !0)
+        throw new S("option " + i + " must be " + u, S.ERR_BAD_OPTION_VALUE);
+      continue;
+    }
+    if (r !== !0)
+      throw new S("Unknown option " + i, S.ERR_BAD_OPTION);
+  }
+}
+const ce = {
+  assertOptions: Yn,
+  validators: Se
+}, B = ce.validators;
+let H = class {
+  constructor(e) {
+    this.defaults = e || {}, this.interceptors = {
+      request: new Ge(),
+      response: new Ge()
+    };
+  }
+  /**
+   * Dispatch a request
+   *
+   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
+   * @param {?Object} config
+   *
+   * @returns {Promise} The Promise to be fulfilled
+   */
+  async request(e, r) {
+    try {
+      return await this._request(e, r);
+    } catch (n) {
+      if (n instanceof Error) {
+        let s = {};
+        Error.captureStackTrace ? Error.captureStackTrace(s) : s = new Error();
+        const i = s.stack ? s.stack.replace(/^.+\n/, "") : "";
+        try {
+          n.stack ? i && !String(n.stack).endsWith(i.replace(/^.+\n.+\n/, "")) && (n.stack += `
+` + i) : n.stack = i;
+        } catch {
+        }
+      }
+      throw n;
+    }
+  }
+  _request(e, r) {
+    typeof e == "string" ? (r = r || {}, r.url = e) : r = e || {}, r = V(this.defaults, r);
+    const { transitional: n, paramsSerializer: s, headers: i } = r;
+    n !== void 0 && ce.assertOptions(n, {
+      silentJSONParsing: B.transitional(B.boolean),
+      forcedJSONParsing: B.transitional(B.boolean),
+      clarifyTimeoutError: B.transitional(B.boolean)
+    }, !1), s != null && (l.isFunction(s) ? r.paramsSerializer = {
+      serialize: s
+    } : ce.assertOptions(s, {
+      encode: B.function,
+      serialize: B.function
+    }, !0)), r.allowAbsoluteUrls !== void 0 || (this.defaults.allowAbsoluteUrls !== void 0 ? r.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls : r.allowAbsoluteUrls = !0), ce.assertOptions(r, {
+      baseUrl: B.spelling("baseURL"),
+      withXsrfToken: B.spelling("withXSRFToken")
+    }, !0), r.method = (r.method || this.defaults.method || "get").toLowerCase();
+    let a = i && l.merge(
+      i.common,
+      i[r.method]
+    );
+    i && l.forEach(
+      ["delete", "get", "head", "post", "put", "patch", "common"],
+      (p) => {
+        delete i[p];
+      }
+    ), r.headers = P.concat(a, i);
+    const o = [];
+    let u = !0;
+    this.interceptors.request.forEach(function(g) {
+      typeof g.runWhen == "function" && g.runWhen(r) === !1 || (u = u && g.synchronous, o.unshift(g.fulfilled, g.rejected));
+    });
+    const c = [];
+    this.interceptors.response.forEach(function(g) {
+      c.push(g.fulfilled, g.rejected);
+    });
+    let f, h = 0, y;
+    if (!u) {
+      const p = [et.bind(this), void 0];
+      for (p.unshift(...o), p.push(...c), y = p.length, f = Promise.resolve(r); h < y; )
+        f = f.then(p[h++], p[h++]);
+      return f;
+    }
+    y = o.length;
+    let w = r;
+    for (h = 0; h < y; ) {
+      const p = o[h++], g = o[h++];
+      try {
+        w = p(w);
+      } catch (m) {
+        g.call(this, m);
+        break;
+      }
+    }
+    try {
+      f = et.call(this, w);
+    } catch (p) {
+      return Promise.reject(p);
+    }
+    for (h = 0, y = c.length; h < y; )
+      f = f.then(c[h++], c[h++]);
+    return f;
+  }
+  getUri(e) {
+    e = V(this.defaults, e);
+    const r = Nt(e.baseURL, e.url, e.allowAbsoluteUrls);
+    return xt(r, e.params, e.paramsSerializer);
+  }
+};
+l.forEach(["delete", "get", "head", "options"], function(e) {
+  H.prototype[e] = function(r, n) {
+    return this.request(V(n || {}, {
+      method: e,
+      url: r,
+      data: (n || {}).data
+    }));
+  };
+});
+l.forEach(["post", "put", "patch"], function(e) {
+  function r(n) {
+    return function(i, a, o) {
+      return this.request(V(o || {}, {
+        method: e,
+        headers: n ? {
+          "Content-Type": "multipart/form-data"
+        } : {},
+        url: i,
+        data: a
+      }));
+    };
+  }
+  H.prototype[e] = r(), H.prototype[e + "Form"] = r(!0);
+});
+let Wn = class Mt {
+  constructor(e) {
+    if (typeof e != "function")
+      throw new TypeError("executor must be a function.");
+    let r;
+    this.promise = new Promise(function(i) {
+      r = i;
+    });
+    const n = this;
+    this.promise.then((s) => {
+      if (!n._listeners) return;
+      let i = n._listeners.length;
+      for (; i-- > 0; )
+        n._listeners[i](s);
+      n._listeners = null;
+    }), this.promise.then = (s) => {
+      let i;
+      const a = new Promise((o) => {
+        n.subscribe(o), i = o;
+      }).then(s);
+      return a.cancel = function() {
+        n.unsubscribe(i);
+      }, a;
+    }, e(function(i, a, o) {
+      n.reason || (n.reason = new Y(i, a, o), r(n.reason));
+    });
+  }
+  /**
+   * Throws a `CanceledError` if cancellation has been requested.
+   */
+  throwIfRequested() {
+    if (this.reason)
+      throw this.reason;
+  }
+  /**
+   * Subscribe to the cancel signal
+   */
+  subscribe(e) {
+    if (this.reason) {
+      e(this.reason);
+      return;
+    }
+    this._listeners ? this._listeners.push(e) : this._listeners = [e];
+  }
+  /**
+   * Unsubscribe from the cancel signal
+   */
+  unsubscribe(e) {
+    if (!this._listeners)
+      return;
+    const r = this._listeners.indexOf(e);
+    r !== -1 && this._listeners.splice(r, 1);
+  }
+  toAbortSignal() {
+    const e = new AbortController(), r = (n) => {
+      e.abort(n);
+    };
+    return this.subscribe(r), e.signal.unsubscribe = () => this.unsubscribe(r), e.signal;
+  }
+  /**
+   * Returns an object that contains a new `CancelToken` and a function that, when called,
+   * cancels the `CancelToken`.
+   */
+  static source() {
+    let e;
+    return {
+      token: new Mt(function(s) {
+        e = s;
+      }),
+      cancel: e
+    };
+  }
+};
+function Xn(t) {
+  return function(r) {
+    return t.apply(null, r);
+  };
+}
+function Zn(t) {
+  return l.isObject(t) && t.isAxiosError === !0;
+}
+const Pe = {
+  Continue: 100,
+  SwitchingProtocols: 101,
+  Processing: 102,
+  EarlyHints: 103,
+  Ok: 200,
+  Created: 201,
+  Accepted: 202,
+  NonAuthoritativeInformation: 203,
+  NoContent: 204,
+  ResetContent: 205,
+  PartialContent: 206,
+  MultiStatus: 207,
+  AlreadyReported: 208,
+  ImUsed: 226,
+  MultipleChoices: 300,
+  MovedPermanently: 301,
+  Found: 302,
+  SeeOther: 303,
+  NotModified: 304,
+  UseProxy: 305,
+  Unused: 306,
+  TemporaryRedirect: 307,
+  PermanentRedirect: 308,
+  BadRequest: 400,
+  Unauthorized: 401,
+  PaymentRequired: 402,
+  Forbidden: 403,
+  NotFound: 404,
+  MethodNotAllowed: 405,
+  NotAcceptable: 406,
+  ProxyAuthenticationRequired: 407,
+  RequestTimeout: 408,
+  Conflict: 409,
+  Gone: 410,
+  LengthRequired: 411,
+  PreconditionFailed: 412,
+  PayloadTooLarge: 413,
+  UriTooLong: 414,
+  UnsupportedMediaType: 415,
+  RangeNotSatisfiable: 416,
+  ExpectationFailed: 417,
+  ImATeapot: 418,
+  MisdirectedRequest: 421,
+  UnprocessableEntity: 422,
+  Locked: 423,
+  FailedDependency: 424,
+  TooEarly: 425,
+  UpgradeRequired: 426,
+  PreconditionRequired: 428,
+  TooManyRequests: 429,
+  RequestHeaderFieldsTooLarge: 431,
+  UnavailableForLegalReasons: 451,
+  InternalServerError: 500,
+  NotImplemented: 501,
+  BadGateway: 502,
+  ServiceUnavailable: 503,
+  GatewayTimeout: 504,
+  HttpVersionNotSupported: 505,
+  VariantAlsoNegotiates: 506,
+  InsufficientStorage: 507,
+  LoopDetected: 508,
+  NotExtended: 510,
+  NetworkAuthenticationRequired: 511
+};
+Object.entries(Pe).forEach(([t, e]) => {
+  Pe[e] = t;
+});
+function jt(t) {
+  const e = new H(t), r = pt(H.prototype.request, e);
+  return l.extend(r, H.prototype, e, { allOwnKeys: !0 }), l.extend(r, e, null, { allOwnKeys: !0 }), r.create = function(s) {
+    return jt(V(t, s));
+  }, r;
+}
+const A = jt(ne);
+A.Axios = H;
+A.CanceledError = Y;
+A.CancelToken = Wn;
+A.isCancel = Dt;
+A.VERSION = Bt;
+A.toFormData = ye;
+A.AxiosError = S;
+A.Cancel = A.CanceledError;
+A.all = function(e) {
+  return Promise.all(e);
+};
+A.spread = Xn;
+A.isAxiosError = Zn;
+A.mergeConfig = V;
+A.AxiosHeaders = P;
+A.formToJSON = (t) => Ft(l.isHTMLForm(t) ? new FormData(t) : t);
+A.getAdapter = $t.getAdapter;
+A.HttpStatusCode = Pe;
+A.default = A;
+const {
+  Axios: $s,
+  AxiosError: Bs,
+  CanceledError: Ms,
+  isCancel: js,
+  CancelToken: Is,
+  VERSION: Ls,
+  all: Us,
+  Cancel: qs,
+  isAxiosError: zs,
+  spread: Hs,
+  toFormData: Vs,
+  AxiosHeaders: Gs,
+  HttpStatusCode: Js,
+  formToJSON: Ks,
+  getAdapter: Ys,
+  mergeConfig: Ws
+} = A, It = {
+  timeout: 60 * 1e3,
+  headers: {
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  }
+}, se = (t = "", e) => {
+  const r = A.create({
+    ...It,
+    baseURL: ht[e].php_url
+  });
+  return r.interceptors.request.use(
+    (n) => (t && n.headers && (n.headers.Authorization = `Bearer ${t}`), n),
+    (n) => Promise.reject(n)
+  ), r.interceptors.response.use(
+    (n) => n,
+    (n) => {
+      const { response: s, request: i } = n || {};
+      return Promise.reject(s || i);
+    }
+  ), r;
+}, W = (t = "", e) => {
+  const r = A.create({
+    ...It,
+    baseURL: ht[e].rearch_url
+  });
+  return r.interceptors.request.use(
+    (n) => (t && n.headers && (n.headers.Authorization = `Bearer ${t}`), n),
+    (n) => Promise.reject(n)
+  ), r.interceptors.response.use(
+    (n) => n,
+    (n) => {
+      const { response: s, request: i } = n || {};
+      return Promise.reject(s || i);
+    }
+  ), r;
+}, Qn = "/preferences/doctor", es = "/preferences/visitpad", ts = "/preferences/branch", rs = "patient/search", ns = "../api/modelGetAddPatientSuggestion.php", ss = "appointments/get", is = "/v1/patient/add", as = "/v1/patients", os = "../api/modelSavePatientImage.php", ls = "../api/modelDeletePatientImage.php", us = "/patient/detail", Xs = async (t = "", e = {}, r, n, s) => {
+  const { doc_rid: i = "" } = e;
+  let a = "";
+  Array.isArray(t) ? a = t.map((o) => `&fields_required=${encodeURIComponent(o)}`).join("") : t && (a = `&fields_required=${encodeURIComponent(t)}`);
+  try {
+    const o = await se(s?.token, s.envName).get(
+      `${Qn}/${i || r}?branch_id=${n}` + a
+    ), { data: u } = o || {};
+    return Promise.resolve(u);
+  } catch (o) {
+    return console.error("Error fetching doctor preference:", o), Promise.reject(o);
+  }
+}, Zs = async (t = "", e, r) => {
+  try {
+    const n = await W(r.token, r.envName).get(
+      `${ts}/${e}?fields_required=${t}`
+    ), { data: s } = n || {};
+    return Promise.resolve(s);
+  } catch (n) {
+    return console.log(n), Promise.reject(n);
+  }
+}, cs = async (t, e, r, n, s) => {
+  try {
+    const i = {
+      appnt_date: t,
+      // If empty then will take today's date
+      doctor_role_id: e,
+      doctor_id: n,
+      org_branch_id: r
+    }, a = await W(s.token, s.envName).post(ss, {
+      ...i
+    }), { data: o } = a || {};
+    return Promise.resolve(o);
+  } catch (i) {
+    return i instanceof Error && console.error("Error fetching appointments:", i.message), i?.response?.status === 401 && dt(), Promise.reject(i);
+  }
+}, Qs = async (t, e) => {
+  let r = [];
+  const n = await cs(
+    I().format("YYYY-MM-DD"),
+    t.doctor_role_id,
+    t.branch_id,
+    t.doctor_id,
+    e
+  );
+  n?.appointments?.length && (r = n.appointments), window.filteredUpcomingAppts = [], r.length && (t.term?.length ? window.filteredUpcomingAppts = r.filter((s) => s.org_person_name.length && s.org_person_name.toLowerCase().includes(t.term.toLowerCase()) && s.appnt_date >= I(/* @__PURE__ */ new Date()).format("YYYY-MM-DD") && (s.remote_appnt_status === "CONFIRMED" || s.appnt_status === 0 || s.appnt_status === 3 || s.appnt_status === 5)) : window.filteredUpcomingAppts = r.filter((s) => s.appnt_date >= I(/* @__PURE__ */ new Date()).format("YYYY-MM-DD") && (s.remote_appnt_status === "CONFIRMED" || s.appnt_status === 0 || s.appnt_status === 3 || s.appnt_status === 5)));
+  try {
+    const s = await W(e.token, e.envName).post(
+      rs,
+      t
+    ), { data: i } = s || {};
+    return Promise.resolve(i);
+  } catch (s) {
+    return console.log(s), null;
+  }
+}, ei = async (t) => {
+  try {
+    const e = await se(t.token, t.envName).post(
+      ns
+    ), { data: r } = e || {}, { apiError: n } = r || {};
+    if (n)
+      throw new Error(n);
+    return Promise.resolve(r);
+  } catch (e) {
+    return e instanceof Error && console.error("Error fetching referred by list:", e.message), e?.response?.status === 401 && dt(), Promise.reject(e);
+  }
+}, ti = async (t, e) => {
+  try {
+    const r = await W(e.token, e.envName).post(is, {
+      ...t,
+      token: e.token
+    }), { data: n } = r || {};
+    return Promise.resolve(n);
+  } catch (r) {
+    return Promise.reject(r);
+  }
+}, ri = async (t, e) => {
+  try {
+    const r = await W(e.token, e.envName).put(
+      as + "/" + t?.person_role_id,
+      {
+        ...t
+      }
+    ), { data: n } = r || {};
+    return Promise.resolve(n);
+  } catch (r) {
+    return console.log(r), Promise.reject(r);
+  }
+}, ni = async (t, e) => {
+  try {
+    const r = await se(e.token, e.envName).post(
+      os,
+      t
+    ), { data: n } = r || {};
+    return Promise.resolve(n);
+  } catch (r) {
+    return console.log(r), Promise.reject(r);
+  }
+}, si = async (t, e) => {
+  try {
+    const r = await se(e.token, e.envName).post(
+      ls,
+      t
+    ), { data: n } = r || {};
+    return Promise.resolve(n);
+  } catch (r) {
+    return console.log(r), Promise.reject(r);
+  }
+}, ii = async ({
+  callback: t,
+  payload: e,
+  token_env: r,
+  isCallbackNeeded: n = !0
+}) => {
+  try {
+    const s = e;
+    window?.partner_service_enabled === "1" && (s.partner_service_enabled = !0);
+    const i = await W(r.token, r.envName).post(
+      us,
+      {
+        ...s
+      }
+    ), { data: a } = i || {}, { error: o } = a || {};
+    if (o)
+      throw new Error(o);
+    if (n)
+      t(a);
+    else return a;
+  } catch (s) {
+    console.log(s);
+  }
+}, ai = async ({ doc_id: t = "", doc_rid: e = "" }, r, n, s, i) => {
+  try {
+    const a = {
+      branch_id: n,
+      doctor_id: t || s,
+      doctor_role_id: e || i
+    }, o = await se(r.token, r.envName).post(
+      es,
+      a
+    ), { data: u } = o || {};
+    return Promise.resolve(u);
+  } catch (a) {
+    return console.error("Error fetching visitpad preference:", a), Promise.reject(a);
+  }
+};
+export {
+  Ps as A,
+  Ns as B,
+  ds as C,
+  gs as D,
+  br as E,
+  Xs as F,
+  us as G,
+  ps as H,
+  ai as I,
+  ys as M,
+  hs as O,
+  W as R,
+  bs as S,
+  Zs as a,
+  ei as b,
+  _s as c,
+  Ds as d,
+  Ss as e,
+  ii as f,
+  ws as g,
+  Fs as h,
+  Ts as i,
+  Os as j,
+  Rs as k,
+  ms as l,
+  pr as m,
+  As as n,
+  vs as o,
+  Es as p,
+  ti as q,
+  Qs as r,
+  ni as s,
+  si as t,
+  ri as u,
+  xs as v,
+  yr as w,
+  se as x,
+  wr as y,
+  Sr as z
+};