notu 0.2.0 → 0.2.1

package/dist/notu.js

@@ -0,0 +1,2060 @@
+var Kt = Object.defineProperty;
+var Xt = (e, n, t) => n in e ? Kt(e, n, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[n] = t;
+var h = (e, n, t) => (Xt(e, typeof n != "symbol" ? n + "" : n, t), t);
+class I {
+  constructor() {
+    h(this, "state", "NEW");
+  }
+  new() {
+    return this.state = "NEW", this;
+  }
+  clean() {
+    return this.state = "CLEAN", this;
+  }
+  dirty() {
+    return this.state = "DIRTY", this;
+  }
+  delete() {
+    return this.state = "DELETED", this;
+  }
+  get isNew() {
+    return this.state == "NEW";
+  }
+  get isClean() {
+    return this.state == "CLEAN";
+  }
+  get isDirty() {
+    return this.state == "DIRTY";
+  }
+  get isDeleted() {
+    return this.state == "DELETED";
+  }
+  validate(n = !1) {
+    return !0;
+  }
+}
+class Rt extends I {
+  constructor() {
+    super(...arguments);
+    h(this, "id", 0);
+    h(this, "_name", "");
+    h(this, "_type", "TEXT");
+    h(this, "_spaceId", 0);
+    h(this, "_space", null);
+  }
+  get name() {
+    return this._name;
+  }
+  set name(t) {
+    t !== this._name && (this._name = t, this.isClean && this.dirty());
+  }
+  get type() {
+    return this._type;
+  }
+  set type(t) {
+    if (!this.isNew)
+      throw Error("Cannot change an attribute's type once it has been created.");
+    this._type = t;
+  }
+  get isText() {
+    return this.type == "TEXT";
+  }
+  get isNumber() {
+    return this.type == "NUMBER";
+  }
+  get isBoolean() {
+    return this.type == "BOOLEAN";
+  }
+  get isDate() {
+    return this.type == "DATE";
+  }
+  asText() {
+    return this.type = "TEXT", this;
+  }
+  asNumber() {
+    return this.type = "NUMBER", this;
+  }
+  asBoolean() {
+    return this.type = "BOOLEAN", this;
+  }
+  asDate() {
+    return this.type = "DATE", this;
+  }
+  get spaceId() {
+    return this._spaceId;
+  }
+  set spaceId(t) {
+    var s;
+    t !== this._spaceId && (this._spaceId = t, t !== ((s = this.space) == null ? void 0 : s.id) && (this._space = null), this.isClean && this.dirty());
+  }
+  get space() {
+    return this._space;
+  }
+  set space(t) {
+    this._space = t, this.spaceId = (t == null ? void 0 : t.id) ?? 0;
+  }
+  duplicate() {
+    const t = new Rt();
+    return t.id = this.id, t.name = this.name, t.type = this.type, t.space = this.space, t;
+  }
+  validate(t = !1) {
+    let s = null;
+    if (this.spaceId <= 0 ? s = "Note spaceId must be greater than zero." : !this.isNew && this.id <= 0 && (s = "Attr id must be greater than zero if in non-new state."), t && s != null)
+      throw Error(s);
+    return s == null;
+  }
+  get defaultValue() {
+    switch (this.type) {
+      case "TEXT":
+        return "";
+      case "NUMBER":
+        return 0;
+      case "BOOLEAN":
+        return !1;
+      case "DATE":
+        return /* @__PURE__ */ new Date();
+    }
+  }
+}
+class gn {
+  constructor(n) {
+    h(this, "_client", null);
+    h(this, "_spaces", []);
+    if (!n)
+      throw Error("Client must be set on Environment constructor");
+    this._client = n;
+  }
+  get client() {
+    return this._client;
+  }
+  get spaces() {
+    return this._spaces;
+  }
+  async loadSpaces() {
+    return this._spaces = await this.client.getSpaces(), this.spaces;
+  }
+  async saveSpace(n) {
+    return await this.client.saveSpace(n);
+  }
+  async getNotes(n, t) {
+    return await this.client.getNotes(n, t);
+  }
+  async getNoteCount(n, t) {
+    return await this.client.getNoteCount(n, t);
+  }
+  async saveNote(n) {
+    return (await this.client.saveNotes([n]))[0];
+  }
+  async saveNotes(n) {
+    return await this.client.saveNotes(n);
+  }
+  async customJob(n, t) {
+    return await this.client.customJob(n, t);
+  }
+}
+function St(e, n) {
+  return function() {
+    return e.apply(n, arguments);
+  };
+}
+const { toString: Gt } = Object.prototype, { getPrototypeOf: et } = Object, H = ((e) => (n) => {
+  const t = Gt.call(n);
+  return e[t] || (e[t] = t.slice(8, -1).toLowerCase());
+})(/* @__PURE__ */ Object.create(null)), T = (e) => (e = e.toLowerCase(), (n) => H(n) === e), M = (e) => (n) => typeof n === e, { isArray: C } = Array, D = M("undefined");
+function Qt(e) {
+  return e !== null && !D(e) && e.constructor !== null && !D(e.constructor) && _(e.constructor.isBuffer) && e.constructor.isBuffer(e);
+}
+const Tt = T("ArrayBuffer");
+function Yt(e) {
+  let n;
+  return typeof ArrayBuffer < "u" && ArrayBuffer.isView ? n = ArrayBuffer.isView(e) : n = e && e.buffer && Tt(e.buffer), n;
+}
+const Zt = M("string"), _ = M("function"), Ot = M("number"), J = (e) => e !== null && typeof e == "object", vt = (e) => e === !0 || e === !1, U = (e) => {
+  if (H(e) !== "object")
+    return !1;
+  const n = et(e);
+  return (n === null || n === Object.prototype || Object.getPrototypeOf(n) === null) && !(Symbol.toStringTag in e) && !(Symbol.iterator in e);
+}, te = T("Date"), ee = T("File"), ne = T("Blob"), se = T("FileList"), re = (e) => J(e) && _(e.pipe), ie = (e) => {
+  let n;
+  return e && (typeof FormData == "function" && e instanceof FormData || _(e.append) && ((n = H(e)) === "formdata" || // detect form-data instance
+  n === "object" && _(e.toString) && e.toString() === "[object FormData]"));
+}, oe = T("URLSearchParams"), ae = (e) => e.trim ? e.trim() : e.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
+function B(e, n, { allOwnKeys: t = !1 } = {}) {
+  if (e === null || typeof e > "u")
+    return;
+  let s, r;
+  if (typeof e != "object" && (e = [e]), C(e))
+    for (s = 0, r = e.length; s < r; s++)
+      n.call(null, e[s], s, e);
+  else {
+    const i = t ? Object.getOwnPropertyNames(e) : Object.keys(e), o = i.length;
+    let c;
+    for (s = 0; s < o; s++)
+      c = i[s], n.call(null, e[c], c, e);
+  }
+}
+function At(e, n) {
+  n = n.toLowerCase();
+  const t = Object.keys(e);
+  let s = t.length, r;
+  for (; s-- > 0; )
+    if (r = t[s], n === r.toLowerCase())
+      return r;
+  return null;
+}
+const Nt = (() => typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : global)(), xt = (e) => !D(e) && e !== Nt;
+function G() {
+  const { caseless: e } = xt(this) && this || {}, n = {}, t = (s, r) => {
+    const i = e && At(n, r) || r;
+    U(n[i]) && U(s) ? n[i] = G(n[i], s) : U(s) ? n[i] = G({}, s) : C(s) ? n[i] = s.slice() : n[i] = s;
+  };
+  for (let s = 0, r = arguments.length; s < r; s++)
+    arguments[s] && B(arguments[s], t);
+  return n;
+}
+const ce = (e, n, t, { allOwnKeys: s } = {}) => (B(n, (r, i) => {
+  t && _(r) ? e[i] = St(r, t) : e[i] = r;
+}, { allOwnKeys: s }), e), ue = (e) => (e.charCodeAt(0) === 65279 && (e = e.slice(1)), e), le = (e, n, t, s) => {
+  e.prototype = Object.create(n.prototype, s), e.prototype.constructor = e, Object.defineProperty(e, "super", {
+    value: n.prototype
+  }), t && Object.assign(e.prototype, t);
+}, de = (e, n, t, s) => {
+  let r, i, o;
+  const c = {};
+  if (n = n || {}, e == null)
+    return n;
+  do {
+    for (r = Object.getOwnPropertyNames(e), i = r.length; i-- > 0; )
+      o = r[i], (!s || s(o, e, n)) && !c[o] && (n[o] = e[o], c[o] = !0);
+    e = t !== !1 && et(e);
+  } while (e && (!t || t(e, n)) && e !== Object.prototype);
+  return n;
+}, he = (e, n, t) => {
+  e = String(e), (t === void 0 || t > e.length) && (t = e.length), t -= n.length;
+  const s = e.indexOf(n, t);
+  return s !== -1 && s === t;
+}, fe = (e) => {
+  if (!e)
+    return null;
+  if (C(e))
+    return e;
+  let n = e.length;
+  if (!Ot(n))
+    return null;
+  const t = new Array(n);
+  for (; n-- > 0; )
+    t[n] = e[n];
+  return t;
+}, pe = ((e) => (n) => e && n instanceof e)(typeof Uint8Array < "u" && et(Uint8Array)), me = (e, n) => {
+  const s = (e && e[Symbol.iterator]).call(e);
+  let r;
+  for (; (r = s.next()) && !r.done; ) {
+    const i = r.value;
+    n.call(e, i[0], i[1]);
+  }
+}, ge = (e, n) => {
+  let t;
+  const s = [];
+  for (; (t = e.exec(n)) !== null; )
+    s.push(t);
+  return s;
+}, we = T("HTMLFormElement"), ye = (e) => e.toLowerCase().replace(
+  /[-_\s]([a-z\d])(\w*)/g,
+  function(t, s, r) {
+    return s.toUpperCase() + r;
+  }
+), lt = (({ hasOwnProperty: e }) => (n, t) => e.call(n, t))(Object.prototype), Ee = T("RegExp"), It = (e, n) => {
+  const t = Object.getOwnPropertyDescriptors(e), s = {};
+  B(t, (r, i) => {
+    let o;
+    (o = n(r, i, e)) !== !1 && (s[i] = o || r);
+  }), Object.defineProperties(e, s);
+}, be = (e) => {
+  It(e, (n, t) => {
+    if (_(e) && ["arguments", "caller", "callee"].indexOf(t) !== -1)
+      return !1;
+    const s = e[t];
+    if (_(s)) {
+      if (n.enumerable = !1, "writable" in n) {
+        n.writable = !1;
+        return;
+      }
+      n.set || (n.set = () => {
+        throw Error("Can not rewrite read-only method '" + t + "'");
+      });
+    }
+  });
+}, _e = (e, n) => {
+  const t = {}, s = (r) => {
+    r.forEach((i) => {
+      t[i] = !0;
+    });
+  };
+  return C(e) ? s(e) : s(String(e).split(n)), t;
+}, Re = () => {
+}, Se = (e, n) => (e = +e, Number.isFinite(e) ? e : n), V = "abcdefghijklmnopqrstuvwxyz", dt = "0123456789", Ct = {
+  DIGIT: dt,
+  ALPHA: V,
+  ALPHA_DIGIT: V + V.toUpperCase() + dt
+}, Te = (e = 16, n = Ct.ALPHA_DIGIT) => {
+  let t = "";
+  const { length: s } = n;
+  for (; e--; )
+    t += n[Math.random() * s | 0];
+  return t;
+};
+function Oe(e) {
+  return !!(e && _(e.append) && e[Symbol.toStringTag] === "FormData" && e[Symbol.iterator]);
+}
+const Ae = (e) => {
+  const n = new Array(10), t = (s, r) => {
+    if (J(s)) {
+      if (n.indexOf(s) >= 0)
+        return;
+      if (!("toJSON" in s)) {
+        n[r] = s;
+        const i = C(s) ? [] : {};
+        return B(s, (o, c) => {
+          const d = t(o, r + 1);
+          !D(d) && (i[c] = d);
+        }), n[r] = void 0, i;
+      }
+    }
+    return s;
+  };
+  return t(e, 0);
+}, Ne = T("AsyncFunction"), xe = (e) => e && (J(e) || _(e)) && _(e.then) && _(e.catch), a = {
+  isArray: C,
+  isArrayBuffer: Tt,
+  isBuffer: Qt,
+  isFormData: ie,
+  isArrayBufferView: Yt,
+  isString: Zt,
+  isNumber: Ot,
+  isBoolean: vt,
+  isObject: J,
+  isPlainObject: U,
+  isUndefined: D,
+  isDate: te,
+  isFile: ee,
+  isBlob: ne,
+  isRegExp: Ee,
+  isFunction: _,
+  isStream: re,
+  isURLSearchParams: oe,
+  isTypedArray: pe,
+  isFileList: se,
+  forEach: B,
+  merge: G,
+  extend: ce,
+  trim: ae,
+  stripBOM: ue,
+  inherits: le,
+  toFlatObject: de,
+  kindOf: H,
+  kindOfTest: T,
+  endsWith: he,
+  toArray: fe,
+  forEachEntry: me,
+  matchAll: ge,
+  isHTMLForm: we,
+  hasOwnProperty: lt,
+  hasOwnProp: lt,
+  // an alias to avoid ESLint no-prototype-builtins detection
+  reduceDescriptors: It,
+  freezeMethods: be,
+  toObjectSet: _e,
+  toCamelCase: ye,
+  noop: Re,
+  toFiniteNumber: Se,
+  findKey: At,
+  global: Nt,
+  isContextDefined: xt,
+  ALPHABET: Ct,
+  generateString: Te,
+  isSpecCompliantForm: Oe,
+  toJSONObject: Ae,
+  isAsyncFn: Ne,
+  isThenable: xe
+};
+function g(e, n, t, s, r) {
+  Error.call(this), Error.captureStackTrace ? Error.captureStackTrace(this, this.constructor) : this.stack = new Error().stack, this.message = e, this.name = "AxiosError", n && (this.code = n), t && (this.config = t), s && (this.request = s), r && (this.response = r);
+}
+a.inherits(g, 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: a.toJSONObject(this.config),
+      code: this.code,
+      status: this.response && this.response.status ? this.response.status : null
+    };
+  }
+});
+const Pt = g.prototype, Dt = {};
+[
+  "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((e) => {
+  Dt[e] = { value: e };
+});
+Object.defineProperties(g, Dt);
+Object.defineProperty(Pt, "isAxiosError", { value: !0 });
+g.from = (e, n, t, s, r, i) => {
+  const o = Object.create(Pt);
+  return a.toFlatObject(e, o, function(d) {
+    return d !== Error.prototype;
+  }, (c) => c !== "isAxiosError"), g.call(o, e.message, n, t, s, r), o.cause = e, o.name = e.name, i && Object.assign(o, i), o;
+};
+const Ie = null;
+function Q(e) {
+  return a.isPlainObject(e) || a.isArray(e);
+}
+function Bt(e) {
+  return a.endsWith(e, "[]") ? e.slice(0, -2) : e;
+}
+function ht(e, n, t) {
+  return e ? e.concat(n).map(function(r, i) {
+    return r = Bt(r), !t && i ? "[" + r + "]" : r;
+  }).join(t ? "." : "") : n;
+}
+function Ce(e) {
+  return a.isArray(e) && !e.some(Q);
+}
+const Pe = a.toFlatObject(a, {}, null, function(n) {
+  return /^is[A-Z]/.test(n);
+});
+function q(e, n, t) {
+  if (!a.isObject(e))
+    throw new TypeError("target must be an object");
+  n = n || new FormData(), t = a.toFlatObject(t, {
+    metaTokens: !0,
+    dots: !1,
+    indexes: !1
+  }, !1, function(m, b) {
+    return !a.isUndefined(b[m]);
+  });
+  const s = t.metaTokens, r = t.visitor || u, i = t.dots, o = t.indexes, d = (t.Blob || typeof Blob < "u" && Blob) && a.isSpecCompliantForm(n);
+  if (!a.isFunction(r))
+    throw new TypeError("visitor must be a function");
+  function f(l) {
+    if (l === null)
+      return "";
+    if (a.isDate(l))
+      return l.toISOString();
+    if (!d && a.isBlob(l))
+      throw new g("Blob is not supported. Use a Buffer instead.");
+    return a.isArrayBuffer(l) || a.isTypedArray(l) ? d && typeof Blob == "function" ? new Blob([l]) : Buffer.from(l) : l;
+  }
+  function u(l, m, b) {
+    let O = l;
+    if (l && !b && typeof l == "object") {
+      if (a.endsWith(m, "{}"))
+        m = s ? m : m.slice(0, -2), l = JSON.stringify(l);
+      else if (a.isArray(l) && Ce(l) || (a.isFileList(l) || a.endsWith(m, "[]")) && (O = a.toArray(l)))
+        return m = Bt(m), O.forEach(function(L, Wt) {
+          !(a.isUndefined(L) || L === null) && n.append(
+            // eslint-disable-next-line no-nested-ternary
+            o === !0 ? ht([m], Wt, i) : o === null ? m : m + "[]",
+            f(L)
+          );
+        }), !1;
+    }
+    return Q(l) ? !0 : (n.append(ht(b, m, i), f(l)), !1);
+  }
+  const p = [], y = Object.assign(Pe, {
+    defaultVisitor: u,
+    convertValue: f,
+    isVisitable: Q
+  });
+  function E(l, m) {
+    if (!a.isUndefined(l)) {
+      if (p.indexOf(l) !== -1)
+        throw Error("Circular reference detected in " + m.join("."));
+      p.push(l), a.forEach(l, function(O, R) {
+        (!(a.isUndefined(O) || O === null) && r.call(
+          n,
+          O,
+          a.isString(R) ? R.trim() : R,
+          m,
+          y
+        )) === !0 && E(O, m ? m.concat(R) : [R]);
+      }), p.pop();
+    }
+  }
+  if (!a.isObject(e))
+    throw new TypeError("data must be an object");
+  return E(e), n;
+}
+function ft(e) {
+  const n = {
+    "!": "%21",
+    "'": "%27",
+    "(": "%28",
+    ")": "%29",
+    "~": "%7E",
+    "%20": "+",
+    "%00": "\0"
+  };
+  return encodeURIComponent(e).replace(/[!'()~]|%20|%00/g, function(s) {
+    return n[s];
+  });
+}
+function nt(e, n) {
+  this._pairs = [], e && q(e, this, n);
+}
+const Ft = nt.prototype;
+Ft.append = function(n, t) {
+  this._pairs.push([n, t]);
+};
+Ft.toString = function(n) {
+  const t = n ? function(s) {
+    return n.call(this, s, ft);
+  } : ft;
+  return this._pairs.map(function(r) {
+    return t(r[0]) + "=" + t(r[1]);
+  }, "").join("&");
+};
+function De(e) {
+  return encodeURIComponent(e).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+}
+function Lt(e, n, t) {
+  if (!n)
+    return e;
+  const s = t && t.encode || De, r = t && t.serialize;
+  let i;
+  if (r ? i = r(n, t) : i = a.isURLSearchParams(n) ? n.toString() : new nt(n, t).toString(s), i) {
+    const o = e.indexOf("#");
+    o !== -1 && (e = e.slice(0, o)), e += (e.indexOf("?") === -1 ? "?" : "&") + i;
+  }
+  return e;
+}
+class Be {
+  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(n, t, s) {
+    return this.handlers.push({
+      fulfilled: n,
+      rejected: t,
+      synchronous: s ? s.synchronous : !1,
+      runWhen: s ? s.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(n) {
+    this.handlers[n] && (this.handlers[n] = 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(n) {
+    a.forEach(this.handlers, function(s) {
+      s !== null && n(s);
+    });
+  }
+}
+const pt = Be, Ut = {
+  silentJSONParsing: !0,
+  forcedJSONParsing: !0,
+  clarifyTimeoutError: !1
+}, Fe = typeof URLSearchParams < "u" ? URLSearchParams : nt, Le = typeof FormData < "u" ? FormData : null, Ue = typeof Blob < "u" ? Blob : null, ke = (() => {
+  let e;
+  return typeof navigator < "u" && ((e = navigator.product) === "ReactNative" || e === "NativeScript" || e === "NS") ? !1 : typeof window < "u" && typeof document < "u";
+})(), je = (() => typeof WorkerGlobalScope < "u" && // eslint-disable-next-line no-undef
+self instanceof WorkerGlobalScope && typeof self.importScripts == "function")(), S = {
+  isBrowser: !0,
+  classes: {
+    URLSearchParams: Fe,
+    FormData: Le,
+    Blob: Ue
+  },
+  isStandardBrowserEnv: ke,
+  isStandardBrowserWebWorkerEnv: je,
+  protocols: ["http", "https", "file", "blob", "url", "data"]
+};
+function ze(e, n) {
+  return q(e, new S.classes.URLSearchParams(), Object.assign({
+    visitor: function(t, s, r, i) {
+      return S.isNode && a.isBuffer(t) ? (this.append(s, t.toString("base64")), !1) : i.defaultVisitor.apply(this, arguments);
+    }
+  }, n));
+}
+function He(e) {
+  return a.matchAll(/\w+|\[(\w*)]/g, e).map((n) => n[0] === "[]" ? "" : n[1] || n[0]);
+}
+function Me(e) {
+  const n = {}, t = Object.keys(e);
+  let s;
+  const r = t.length;
+  let i;
+  for (s = 0; s < r; s++)
+    i = t[s], n[i] = e[i];
+  return n;
+}
+function kt(e) {
+  function n(t, s, r, i) {
+    let o = t[i++];
+    const c = Number.isFinite(+o), d = i >= t.length;
+    return o = !o && a.isArray(r) ? r.length : o, d ? (a.hasOwnProp(r, o) ? r[o] = [r[o], s] : r[o] = s, !c) : ((!r[o] || !a.isObject(r[o])) && (r[o] = []), n(t, s, r[o], i) && a.isArray(r[o]) && (r[o] = Me(r[o])), !c);
+  }
+  if (a.isFormData(e) && a.isFunction(e.entries)) {
+    const t = {};
+    return a.forEachEntry(e, (s, r) => {
+      n(He(s), r, t, 0);
+    }), t;
+  }
+  return null;
+}
+function Je(e, n, t) {
+  if (a.isString(e))
+    try {
+      return (n || JSON.parse)(e), a.trim(e);
+    } catch (s) {
+      if (s.name !== "SyntaxError")
+        throw s;
+    }
+  return (t || JSON.stringify)(e);
+}
+const st = {
+  transitional: Ut,
+  adapter: ["xhr", "http"],
+  transformRequest: [function(n, t) {
+    const s = t.getContentType() || "", r = s.indexOf("application/json") > -1, i = a.isObject(n);
+    if (i && a.isHTMLForm(n) && (n = new FormData(n)), a.isFormData(n))
+      return r && r ? JSON.stringify(kt(n)) : n;
+    if (a.isArrayBuffer(n) || a.isBuffer(n) || a.isStream(n) || a.isFile(n) || a.isBlob(n))
+      return n;
+    if (a.isArrayBufferView(n))
+      return n.buffer;
+    if (a.isURLSearchParams(n))
+      return t.setContentType("application/x-www-form-urlencoded;charset=utf-8", !1), n.toString();
+    let c;
+    if (i) {
+      if (s.indexOf("application/x-www-form-urlencoded") > -1)
+        return ze(n, this.formSerializer).toString();
+      if ((c = a.isFileList(n)) || s.indexOf("multipart/form-data") > -1) {
+        const d = this.env && this.env.FormData;
+        return q(
+          c ? { "files[]": n } : n,
+          d && new d(),
+          this.formSerializer
+        );
+      }
+    }
+    return i || r ? (t.setContentType("application/json", !1), Je(n)) : n;
+  }],
+  transformResponse: [function(n) {
+    const t = this.transitional || st.transitional, s = t && t.forcedJSONParsing, r = this.responseType === "json";
+    if (n && a.isString(n) && (s && !this.responseType || r)) {
+      const o = !(t && t.silentJSONParsing) && r;
+      try {
+        return JSON.parse(n);
+      } catch (c) {
+        if (o)
+          throw c.name === "SyntaxError" ? g.from(c, g.ERR_BAD_RESPONSE, this, null, this.response) : c;
+      }
+    }
+    return n;
+  }],
+  /**
+   * 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: S.classes.FormData,
+    Blob: S.classes.Blob
+  },
+  validateStatus: function(n) {
+    return n >= 200 && n < 300;
+  },
+  headers: {
+    common: {
+      Accept: "application/json, text/plain, */*",
+      "Content-Type": void 0
+    }
+  }
+};
+a.forEach(["delete", "get", "head", "post", "put", "patch"], (e) => {
+  st.headers[e] = {};
+});
+const rt = st, qe = a.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"
+]), $e = (e) => {
+  const n = {};
+  let t, s, r;
+  return e && e.split(`
+`).forEach(function(o) {
+    r = o.indexOf(":"), t = o.substring(0, r).trim().toLowerCase(), s = o.substring(r + 1).trim(), !(!t || n[t] && qe[t]) && (t === "set-cookie" ? n[t] ? n[t].push(s) : n[t] = [s] : n[t] = n[t] ? n[t] + ", " + s : s);
+  }), n;
+}, mt = Symbol("internals");
+function P(e) {
+  return e && String(e).trim().toLowerCase();
+}
+function k(e) {
+  return e === !1 || e == null ? e : a.isArray(e) ? e.map(k) : String(e);
+}
+function Ve(e) {
+  const n = /* @__PURE__ */ Object.create(null), t = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
+  let s;
+  for (; s = t.exec(e); )
+    n[s[1]] = s[2];
+  return n;
+}
+const We = (e) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(e.trim());
+function W(e, n, t, s, r) {
+  if (a.isFunction(s))
+    return s.call(this, n, t);
+  if (r && (n = t), !!a.isString(n)) {
+    if (a.isString(s))
+      return n.indexOf(s) !== -1;
+    if (a.isRegExp(s))
+      return s.test(n);
+  }
+}
+function Ke(e) {
+  return e.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (n, t, s) => t.toUpperCase() + s);
+}
+function Xe(e, n) {
+  const t = a.toCamelCase(" " + n);
+  ["get", "set", "has"].forEach((s) => {
+    Object.defineProperty(e, s + t, {
+      value: function(r, i, o) {
+        return this[s].call(this, n, r, i, o);
+      },
+      configurable: !0
+    });
+  });
+}
+class $ {
+  constructor(n) {
+    n && this.set(n);
+  }
+  set(n, t, s) {
+    const r = this;
+    function i(c, d, f) {
+      const u = P(d);
+      if (!u)
+        throw new Error("header name must be a non-empty string");
+      const p = a.findKey(r, u);
+      (!p || r[p] === void 0 || f === !0 || f === void 0 && r[p] !== !1) && (r[p || d] = k(c));
+    }
+    const o = (c, d) => a.forEach(c, (f, u) => i(f, u, d));
+    return a.isPlainObject(n) || n instanceof this.constructor ? o(n, t) : a.isString(n) && (n = n.trim()) && !We(n) ? o($e(n), t) : n != null && i(t, n, s), this;
+  }
+  get(n, t) {
+    if (n = P(n), n) {
+      const s = a.findKey(this, n);
+      if (s) {
+        const r = this[s];
+        if (!t)
+          return r;
+        if (t === !0)
+          return Ve(r);
+        if (a.isFunction(t))
+          return t.call(this, r, s);
+        if (a.isRegExp(t))
+          return t.exec(r);
+        throw new TypeError("parser must be boolean|regexp|function");
+      }
+    }
+  }
+  has(n, t) {
+    if (n = P(n), n) {
+      const s = a.findKey(this, n);
+      return !!(s && this[s] !== void 0 && (!t || W(this, this[s], s, t)));
+    }
+    return !1;
+  }
+  delete(n, t) {
+    const s = this;
+    let r = !1;
+    function i(o) {
+      if (o = P(o), o) {
+        const c = a.findKey(s, o);
+        c && (!t || W(s, s[c], c, t)) && (delete s[c], r = !0);
+      }
+    }
+    return a.isArray(n) ? n.forEach(i) : i(n), r;
+  }
+  clear(n) {
+    const t = Object.keys(this);
+    let s = t.length, r = !1;
+    for (; s--; ) {
+      const i = t[s];
+      (!n || W(this, this[i], i, n, !0)) && (delete this[i], r = !0);
+    }
+    return r;
+  }
+  normalize(n) {
+    const t = this, s = {};
+    return a.forEach(this, (r, i) => {
+      const o = a.findKey(s, i);
+      if (o) {
+        t[o] = k(r), delete t[i];
+        return;
+      }
+      const c = n ? Ke(i) : String(i).trim();
+      c !== i && delete t[i], t[c] = k(r), s[c] = !0;
+    }), this;
+  }
+  concat(...n) {
+    return this.constructor.concat(this, ...n);
+  }
+  toJSON(n) {
+    const t = /* @__PURE__ */ Object.create(null);
+    return a.forEach(this, (s, r) => {
+      s != null && s !== !1 && (t[r] = n && a.isArray(s) ? s.join(", ") : s);
+    }), t;
+  }
+  [Symbol.iterator]() {
+    return Object.entries(this.toJSON())[Symbol.iterator]();
+  }
+  toString() {
+    return Object.entries(this.toJSON()).map(([n, t]) => n + ": " + t).join(`
+`);
+  }
+  get [Symbol.toStringTag]() {
+    return "AxiosHeaders";
+  }
+  static from(n) {
+    return n instanceof this ? n : new this(n);
+  }
+  static concat(n, ...t) {
+    const s = new this(n);
+    return t.forEach((r) => s.set(r)), s;
+  }
+  static accessor(n) {
+    const s = (this[mt] = this[mt] = {
+      accessors: {}
+    }).accessors, r = this.prototype;
+    function i(o) {
+      const c = P(o);
+      s[c] || (Xe(r, o), s[c] = !0);
+    }
+    return a.isArray(n) ? n.forEach(i) : i(n), this;
+  }
+}
+$.accessor(["Content-Type", "Content-Length", "Accept", "Accept-Encoding", "User-Agent", "Authorization"]);
+a.reduceDescriptors($.prototype, ({ value: e }, n) => {
+  let t = n[0].toUpperCase() + n.slice(1);
+  return {
+    get: () => e,
+    set(s) {
+      this[t] = s;
+    }
+  };
+});
+a.freezeMethods($);
+const A = $;
+function K(e, n) {
+  const t = this || rt, s = n || t, r = A.from(s.headers);
+  let i = s.data;
+  return a.forEach(e, function(c) {
+    i = c.call(t, i, r.normalize(), n ? n.status : void 0);
+  }), r.normalize(), i;
+}
+function jt(e) {
+  return !!(e && e.__CANCEL__);
+}
+function F(e, n, t) {
+  g.call(this, e ?? "canceled", g.ERR_CANCELED, n, t), this.name = "CanceledError";
+}
+a.inherits(F, g, {
+  __CANCEL__: !0
+});
+function Ge(e, n, t) {
+  const s = t.config.validateStatus;
+  !t.status || !s || s(t.status) ? e(t) : n(new g(
+    "Request failed with status code " + t.status,
+    [g.ERR_BAD_REQUEST, g.ERR_BAD_RESPONSE][Math.floor(t.status / 100) - 4],
+    t.config,
+    t.request,
+    t
+  ));
+}
+const Qe = S.isStandardBrowserEnv ? (
+  // Standard browser envs support document.cookie
+  function() {
+    return {
+      write: function(t, s, r, i, o, c) {
+        const d = [];
+        d.push(t + "=" + encodeURIComponent(s)), a.isNumber(r) && d.push("expires=" + new Date(r).toGMTString()), a.isString(i) && d.push("path=" + i), a.isString(o) && d.push("domain=" + o), c === !0 && d.push("secure"), document.cookie = d.join("; ");
+      },
+      read: function(t) {
+        const s = document.cookie.match(new RegExp("(^|;\\s*)(" + t + ")=([^;]*)"));
+        return s ? decodeURIComponent(s[3]) : null;
+      },
+      remove: function(t) {
+        this.write(t, "", Date.now() - 864e5);
+      }
+    };
+  }()
+) : (
+  // Non standard browser env (web workers, react-native) lack needed support.
+  function() {
+    return {
+      write: function() {
+      },
+      read: function() {
+        return null;
+      },
+      remove: function() {
+      }
+    };
+  }()
+);
+function Ye(e) {
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(e);
+}
+function Ze(e, n) {
+  return n ? e.replace(/\/+$/, "") + "/" + n.replace(/^\/+/, "") : e;
+}
+function zt(e, n) {
+  return e && !Ye(n) ? Ze(e, n) : n;
+}
+const ve = S.isStandardBrowserEnv ? (
+  // Standard browser envs have full support of the APIs needed to test
+  // whether the request URL is of the same origin as current location.
+  function() {
+    const n = /(msie|trident)/i.test(navigator.userAgent), t = document.createElement("a");
+    let s;
+    function r(i) {
+      let o = i;
+      return n && (t.setAttribute("href", o), o = t.href), t.setAttribute("href", o), {
+        href: t.href,
+        protocol: t.protocol ? t.protocol.replace(/:$/, "") : "",
+        host: t.host,
+        search: t.search ? t.search.replace(/^\?/, "") : "",
+        hash: t.hash ? t.hash.replace(/^#/, "") : "",
+        hostname: t.hostname,
+        port: t.port,
+        pathname: t.pathname.charAt(0) === "/" ? t.pathname : "/" + t.pathname
+      };
+    }
+    return s = r(window.location.href), function(o) {
+      const c = a.isString(o) ? r(o) : o;
+      return c.protocol === s.protocol && c.host === s.host;
+    };
+  }()
+) : (
+  // Non standard browser envs (web workers, react-native) lack needed support.
+  function() {
+    return function() {
+      return !0;
+    };
+  }()
+);
+function tn(e) {
+  const n = /^([-+\w]{1,25})(:?\/\/|:)/.exec(e);
+  return n && n[1] || "";
+}
+function en(e, n) {
+  e = e || 10;
+  const t = new Array(e), s = new Array(e);
+  let r = 0, i = 0, o;
+  return n = n !== void 0 ? n : 1e3, function(d) {
+    const f = Date.now(), u = s[i];
+    o || (o = f), t[r] = d, s[r] = f;
+    let p = i, y = 0;
+    for (; p !== r; )
+      y += t[p++], p = p % e;
+    if (r = (r + 1) % e, r === i && (i = (i + 1) % e), f - o < n)
+      return;
+    const E = u && f - u;
+    return E ? Math.round(y * 1e3 / E) : void 0;
+  };
+}
+function gt(e, n) {
+  let t = 0;
+  const s = en(50, 250);
+  return (r) => {
+    const i = r.loaded, o = r.lengthComputable ? r.total : void 0, c = i - t, d = s(c), f = i <= o;
+    t = i;
+    const u = {
+      loaded: i,
+      total: o,
+      progress: o ? i / o : void 0,
+      bytes: c,
+      rate: d || void 0,
+      estimated: d && o && f ? (o - i) / d : void 0,
+      event: r
+    };
+    u[n ? "download" : "upload"] = !0, e(u);
+  };
+}
+const nn = typeof XMLHttpRequest < "u", sn = nn && function(e) {
+  return new Promise(function(t, s) {
+    let r = e.data;
+    const i = A.from(e.headers).normalize(), o = e.responseType;
+    let c;
+    function d() {
+      e.cancelToken && e.cancelToken.unsubscribe(c), e.signal && e.signal.removeEventListener("abort", c);
+    }
+    let f;
+    a.isFormData(r) && (S.isStandardBrowserEnv || S.isStandardBrowserWebWorkerEnv ? i.setContentType(!1) : i.getContentType(/^\s*multipart\/form-data/) ? a.isString(f = i.getContentType()) && i.setContentType(f.replace(/^\s*(multipart\/form-data);+/, "$1")) : i.setContentType("multipart/form-data"));
+    let u = new XMLHttpRequest();
+    if (e.auth) {
+      const l = e.auth.username || "", m = e.auth.password ? unescape(encodeURIComponent(e.auth.password)) : "";
+      i.set("Authorization", "Basic " + btoa(l + ":" + m));
+    }
+    const p = zt(e.baseURL, e.url);
+    u.open(e.method.toUpperCase(), Lt(p, e.params, e.paramsSerializer), !0), u.timeout = e.timeout;
+    function y() {
+      if (!u)
+        return;
+      const l = A.from(
+        "getAllResponseHeaders" in u && u.getAllResponseHeaders()
+      ), b = {
+        data: !o || o === "text" || o === "json" ? u.responseText : u.response,
+        status: u.status,
+        statusText: u.statusText,
+        headers: l,
+        config: e,
+        request: u
+      };
+      Ge(function(R) {
+        t(R), d();
+      }, function(R) {
+        s(R), d();
+      }, b), u = null;
+    }
+    if ("onloadend" in u ? u.onloadend = y : u.onreadystatechange = function() {
+      !u || u.readyState !== 4 || u.status === 0 && !(u.responseURL && u.responseURL.indexOf("file:") === 0) || setTimeout(y);
+    }, u.onabort = function() {
+      u && (s(new g("Request aborted", g.ECONNABORTED, e, u)), u = null);
+    }, u.onerror = function() {
+      s(new g("Network Error", g.ERR_NETWORK, e, u)), u = null;
+    }, u.ontimeout = function() {
+      let m = e.timeout ? "timeout of " + e.timeout + "ms exceeded" : "timeout exceeded";
+      const b = e.transitional || Ut;
+      e.timeoutErrorMessage && (m = e.timeoutErrorMessage), s(new g(
+        m,
+        b.clarifyTimeoutError ? g.ETIMEDOUT : g.ECONNABORTED,
+        e,
+        u
+      )), u = null;
+    }, S.isStandardBrowserEnv) {
+      const l = (e.withCredentials || ve(p)) && e.xsrfCookieName && Qe.read(e.xsrfCookieName);
+      l && i.set(e.xsrfHeaderName, l);
+    }
+    r === void 0 && i.setContentType(null), "setRequestHeader" in u && a.forEach(i.toJSON(), function(m, b) {
+      u.setRequestHeader(b, m);
+    }), a.isUndefined(e.withCredentials) || (u.withCredentials = !!e.withCredentials), o && o !== "json" && (u.responseType = e.responseType), typeof e.onDownloadProgress == "function" && u.addEventListener("progress", gt(e.onDownloadProgress, !0)), typeof e.onUploadProgress == "function" && u.upload && u.upload.addEventListener("progress", gt(e.onUploadProgress)), (e.cancelToken || e.signal) && (c = (l) => {
+      u && (s(!l || l.type ? new F(null, e, u) : l), u.abort(), u = null);
+    }, e.cancelToken && e.cancelToken.subscribe(c), e.signal && (e.signal.aborted ? c() : e.signal.addEventListener("abort", c)));
+    const E = tn(p);
+    if (E && S.protocols.indexOf(E) === -1) {
+      s(new g("Unsupported protocol " + E + ":", g.ERR_BAD_REQUEST, e));
+      return;
+    }
+    u.send(r || null);
+  });
+}, Y = {
+  http: Ie,
+  xhr: sn
+};
+a.forEach(Y, (e, n) => {
+  if (e) {
+    try {
+      Object.defineProperty(e, "name", { value: n });
+    } catch {
+    }
+    Object.defineProperty(e, "adapterName", { value: n });
+  }
+});
+const wt = (e) => `- ${e}`, rn = (e) => a.isFunction(e) || e === null || e === !1, Ht = {
+  getAdapter: (e) => {
+    e = a.isArray(e) ? e : [e];
+    const { length: n } = e;
+    let t, s;
+    const r = {};
+    for (let i = 0; i < n; i++) {
+      t = e[i];
+      let o;
+      if (s = t, !rn(t) && (s = Y[(o = String(t)).toLowerCase()], s === void 0))
+        throw new g(`Unknown adapter '${o}'`);
+      if (s)
+        break;
+      r[o || "#" + i] = s;
+    }
+    if (!s) {
+      const i = Object.entries(r).map(
+        ([c, d]) => `adapter ${c} ` + (d === !1 ? "is not supported by the environment" : "is not available in the build")
+      );
+      let o = n ? i.length > 1 ? `since :
+` + i.map(wt).join(`
+`) : " " + wt(i[0]) : "as no adapter specified";
+      throw new g(
+        "There is no suitable adapter to dispatch the request " + o,
+        "ERR_NOT_SUPPORT"
+      );
+    }
+    return s;
+  },
+  adapters: Y
+};
+function X(e) {
+  if (e.cancelToken && e.cancelToken.throwIfRequested(), e.signal && e.signal.aborted)
+    throw new F(null, e);
+}
+function yt(e) {
+  return X(e), e.headers = A.from(e.headers), e.data = K.call(
+    e,
+    e.transformRequest
+  ), ["post", "put", "patch"].indexOf(e.method) !== -1 && e.headers.setContentType("application/x-www-form-urlencoded", !1), Ht.getAdapter(e.adapter || rt.adapter)(e).then(function(s) {
+    return X(e), s.data = K.call(
+      e,
+      e.transformResponse,
+      s
+    ), s.headers = A.from(s.headers), s;
+  }, function(s) {
+    return jt(s) || (X(e), s && s.response && (s.response.data = K.call(
+      e,
+      e.transformResponse,
+      s.response
+    ), s.response.headers = A.from(s.response.headers))), Promise.reject(s);
+  });
+}
+const Et = (e) => e instanceof A ? e.toJSON() : e;
+function x(e, n) {
+  n = n || {};
+  const t = {};
+  function s(f, u, p) {
+    return a.isPlainObject(f) && a.isPlainObject(u) ? a.merge.call({ caseless: p }, f, u) : a.isPlainObject(u) ? a.merge({}, u) : a.isArray(u) ? u.slice() : u;
+  }
+  function r(f, u, p) {
+    if (a.isUndefined(u)) {
+      if (!a.isUndefined(f))
+        return s(void 0, f, p);
+    } else
+      return s(f, u, p);
+  }
+  function i(f, u) {
+    if (!a.isUndefined(u))
+      return s(void 0, u);
+  }
+  function o(f, u) {
+    if (a.isUndefined(u)) {
+      if (!a.isUndefined(f))
+        return s(void 0, f);
+    } else
+      return s(void 0, u);
+  }
+  function c(f, u, p) {
+    if (p in n)
+      return s(f, u);
+    if (p in e)
+      return s(void 0, f);
+  }
+  const d = {
+    url: i,
+    method: i,
+    data: i,
+    baseURL: o,
+    transformRequest: o,
+    transformResponse: o,
+    paramsSerializer: o,
+    timeout: o,
+    timeoutMessage: o,
+    withCredentials: o,
+    adapter: o,
+    responseType: o,
+    xsrfCookieName: o,
+    xsrfHeaderName: o,
+    onUploadProgress: o,
+    onDownloadProgress: o,
+    decompress: o,
+    maxContentLength: o,
+    maxBodyLength: o,
+    beforeRedirect: o,
+    transport: o,
+    httpAgent: o,
+    httpsAgent: o,
+    cancelToken: o,
+    socketPath: o,
+    responseEncoding: o,
+    validateStatus: c,
+    headers: (f, u) => r(Et(f), Et(u), !0)
+  };
+  return a.forEach(Object.keys(Object.assign({}, e, n)), function(u) {
+    const p = d[u] || r, y = p(e[u], n[u], u);
+    a.isUndefined(y) && p !== c || (t[u] = y);
+  }), t;
+}
+const Mt = "1.5.1", it = {};
+["object", "boolean", "number", "function", "string", "symbol"].forEach((e, n) => {
+  it[e] = function(s) {
+    return typeof s === e || "a" + (n < 1 ? "n " : " ") + e;
+  };
+});
+const bt = {};
+it.transitional = function(n, t, s) {
+  function r(i, o) {
+    return "[Axios v" + Mt + "] Transitional option '" + i + "'" + o + (s ? ". " + s : "");
+  }
+  return (i, o, c) => {
+    if (n === !1)
+      throw new g(
+        r(o, " has been removed" + (t ? " in " + t : "")),
+        g.ERR_DEPRECATED
+      );
+    return t && !bt[o] && (bt[o] = !0, console.warn(
+      r(
+        o,
+        " has been deprecated since v" + t + " and will be removed in the near future"
+      )
+    )), n ? n(i, o, c) : !0;
+  };
+};
+function on(e, n, t) {
+  if (typeof e != "object")
+    throw new g("options must be an object", g.ERR_BAD_OPTION_VALUE);
+  const s = Object.keys(e);
+  let r = s.length;
+  for (; r-- > 0; ) {
+    const i = s[r], o = n[i];
+    if (o) {
+      const c = e[i], d = c === void 0 || o(c, i, e);
+      if (d !== !0)
+        throw new g("option " + i + " must be " + d, g.ERR_BAD_OPTION_VALUE);
+      continue;
+    }
+    if (t !== !0)
+      throw new g("Unknown option " + i, g.ERR_BAD_OPTION);
+  }
+}
+const Z = {
+  assertOptions: on,
+  validators: it
+}, N = Z.validators;
+class z {
+  constructor(n) {
+    this.defaults = n, this.interceptors = {
+      request: new pt(),
+      response: new pt()
+    };
+  }
+  /**
+   * 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
+   */
+  request(n, t) {
+    typeof n == "string" ? (t = t || {}, t.url = n) : t = n || {}, t = x(this.defaults, t);
+    const { transitional: s, paramsSerializer: r, headers: i } = t;
+    s !== void 0 && Z.assertOptions(s, {
+      silentJSONParsing: N.transitional(N.boolean),
+      forcedJSONParsing: N.transitional(N.boolean),
+      clarifyTimeoutError: N.transitional(N.boolean)
+    }, !1), r != null && (a.isFunction(r) ? t.paramsSerializer = {
+      serialize: r
+    } : Z.assertOptions(r, {
+      encode: N.function,
+      serialize: N.function
+    }, !0)), t.method = (t.method || this.defaults.method || "get").toLowerCase();
+    let o = i && a.merge(
+      i.common,
+      i[t.method]
+    );
+    i && a.forEach(
+      ["delete", "get", "head", "post", "put", "patch", "common"],
+      (l) => {
+        delete i[l];
+      }
+    ), t.headers = A.concat(o, i);
+    const c = [];
+    let d = !0;
+    this.interceptors.request.forEach(function(m) {
+      typeof m.runWhen == "function" && m.runWhen(t) === !1 || (d = d && m.synchronous, c.unshift(m.fulfilled, m.rejected));
+    });
+    const f = [];
+    this.interceptors.response.forEach(function(m) {
+      f.push(m.fulfilled, m.rejected);
+    });
+    let u, p = 0, y;
+    if (!d) {
+      const l = [yt.bind(this), void 0];
+      for (l.unshift.apply(l, c), l.push.apply(l, f), y = l.length, u = Promise.resolve(t); p < y; )
+        u = u.then(l[p++], l[p++]);
+      return u;
+    }
+    y = c.length;
+    let E = t;
+    for (p = 0; p < y; ) {
+      const l = c[p++], m = c[p++];
+      try {
+        E = l(E);
+      } catch (b) {
+        m.call(this, b);
+        break;
+      }
+    }
+    try {
+      u = yt.call(this, E);
+    } catch (l) {
+      return Promise.reject(l);
+    }
+    for (p = 0, y = f.length; p < y; )
+      u = u.then(f[p++], f[p++]);
+    return u;
+  }
+  getUri(n) {
+    n = x(this.defaults, n);
+    const t = zt(n.baseURL, n.url);
+    return Lt(t, n.params, n.paramsSerializer);
+  }
+}
+a.forEach(["delete", "get", "head", "options"], function(n) {
+  z.prototype[n] = function(t, s) {
+    return this.request(x(s || {}, {
+      method: n,
+      url: t,
+      data: (s || {}).data
+    }));
+  };
+});
+a.forEach(["post", "put", "patch"], function(n) {
+  function t(s) {
+    return function(i, o, c) {
+      return this.request(x(c || {}, {
+        method: n,
+        headers: s ? {
+          "Content-Type": "multipart/form-data"
+        } : {},
+        url: i,
+        data: o
+      }));
+    };
+  }
+  z.prototype[n] = t(), z.prototype[n + "Form"] = t(!0);
+});
+const j = z;
+class ot {
+  constructor(n) {
+    if (typeof n != "function")
+      throw new TypeError("executor must be a function.");
+    let t;
+    this.promise = new Promise(function(i) {
+      t = i;
+    });
+    const s = this;
+    this.promise.then((r) => {
+      if (!s._listeners)
+        return;
+      let i = s._listeners.length;
+      for (; i-- > 0; )
+        s._listeners[i](r);
+      s._listeners = null;
+    }), this.promise.then = (r) => {
+      let i;
+      const o = new Promise((c) => {
+        s.subscribe(c), i = c;
+      }).then(r);
+      return o.cancel = function() {
+        s.unsubscribe(i);
+      }, o;
+    }, n(function(i, o, c) {
+      s.reason || (s.reason = new F(i, o, c), t(s.reason));
+    });
+  }
+  /**
+   * Throws a `CanceledError` if cancellation has been requested.
+   */
+  throwIfRequested() {
+    if (this.reason)
+      throw this.reason;
+  }
+  /**
+   * Subscribe to the cancel signal
+   */
+  subscribe(n) {
+    if (this.reason) {
+      n(this.reason);
+      return;
+    }
+    this._listeners ? this._listeners.push(n) : this._listeners = [n];
+  }
+  /**
+   * Unsubscribe from the cancel signal
+   */
+  unsubscribe(n) {
+    if (!this._listeners)
+      return;
+    const t = this._listeners.indexOf(n);
+    t !== -1 && this._listeners.splice(t, 1);
+  }
+  /**
+   * Returns an object that contains a new `CancelToken` and a function that, when called,
+   * cancels the `CancelToken`.
+   */
+  static source() {
+    let n;
+    return {
+      token: new ot(function(r) {
+        n = r;
+      }),
+      cancel: n
+    };
+  }
+}
+const an = ot;
+function cn(e) {
+  return function(t) {
+    return e.apply(null, t);
+  };
+}
+function un(e) {
+  return a.isObject(e) && e.isAxiosError === !0;
+}
+const v = {
+  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(v).forEach(([e, n]) => {
+  v[n] = e;
+});
+const ln = v;
+function Jt(e) {
+  const n = new j(e), t = St(j.prototype.request, n);
+  return a.extend(t, j.prototype, n, { allOwnKeys: !0 }), a.extend(t, n, null, { allOwnKeys: !0 }), t.create = function(r) {
+    return Jt(x(e, r));
+  }, t;
+}
+const w = Jt(rt);
+w.Axios = j;
+w.CanceledError = F;
+w.CancelToken = an;
+w.isCancel = jt;
+w.VERSION = Mt;
+w.toFormData = q;
+w.AxiosError = g;
+w.Cancel = w.CanceledError;
+w.all = function(n) {
+  return Promise.all(n);
+};
+w.spread = cn;
+w.isAxiosError = un;
+w.mergeConfig = x;
+w.AxiosHeaders = A;
+w.formToJSON = (e) => kt(a.isHTMLForm(e) ? new FormData(e) : e);
+w.getAdapter = Ht.getAdapter;
+w.HttpStatusCode = ln;
+w.default = w;
+const dn = w;
+class wn {
+  constructor(n, t = null) {
+    h(this, "_url", null);
+    h(this, "_token", null);
+    //Added for testing support
+    h(this, "_httpRequester");
+    if (!n)
+      throw Error("Endpoint URL must be passed in to NotuClient constructor");
+    this._url = n, this._httpRequester = t ?? dn;
+  }
+  get url() {
+    return this._url;
+  }
+  get token() {
+    return this._token;
+  }
+  set token(n) {
+    this._token = n;
+  }
+  async login(n, t) {
+    try {
+      const s = await this._httpRequester({
+        method: "post",
+        url: (this.url + "/login").replace("//", "/"),
+        data: { username: n, password: t }
+      });
+      return this._token = s.data, { success: !0, error: null, token: s.data };
+    } catch (s) {
+      if (s.response.status == 401)
+        return { success: !1, error: "Invalid username & password.", token: null };
+      throw s;
+    }
+  }
+  async getSpaces() {
+    return (await this._httpRequester({
+      method: "get",
+      url: (this.url + "/spaces").replace("//", "/"),
+      headers: {
+        Authorization: "Bearer " + this.token
+      }
+    })).data;
+  }
+  async saveSpace(n) {
+    return (await this._httpRequester({
+      method: "post",
+      url: (this.url + "/spaces").replace("//", "/"),
+      data: n,
+      headers: {
+        Authorization: "Bearer " + this.token
+      }
+    })).data;
+  }
+  async getNotes(n, t) {
+    return (await this._httpRequester({
+      method: "get",
+      url: (this.url + "/notes").replace("//", "/"),
+      data: { query: n, spaceId: t },
+      headers: {
+        Authorization: "Bearer " + this.token
+      }
+    })).data;
+  }
+  async getNoteCount(n, t) {
+    return (await this._httpRequester({
+      method: "get",
+      url: (this.url + "/notes").replace("//", "/"),
+      data: { query: n, spaceId: t },
+      headers: {
+        Authorization: "Bearer " + this.token
+      }
+    })).data;
+  }
+  async saveNotes(n) {
+    return (await this._httpRequester({
+      method: "post",
+      url: (this.url + "/notes").replace("//", "/"),
+      data: { notes: n },
+      headers: {
+        Authorization: "Bearer " + this.token
+      }
+    })).data;
+  }
+  async customJob(n, t) {
+    return (await this._httpRequester({
+      method: "post",
+      url: (this.url + "customjob").replace("//", "/"),
+      data: { name: n, data: t },
+      headers: {
+        Authorization: "Bearer " + this.token
+      }
+    })).data;
+  }
+}
+class at extends I {
+  constructor() {
+    super(...arguments);
+    h(this, "_noteId", 0);
+    h(this, "_note", null);
+    h(this, "_attrId", 0);
+    h(this, "_attr", null);
+    h(this, "_value", null);
+    h(this, "_tagId", null);
+    h(this, "_tag", null);
+  }
+  get noteId() {
+    return this._noteId;
+  }
+  set noteId(t) {
+    var s;
+    t !== this._noteId && (this._noteId = t, t !== ((s = this.note) == null ? void 0 : s.id) && (this._note = null), this.isClean && this.dirty());
+  }
+  get note() {
+    return this._note;
+  }
+  set note(t) {
+    this._note = t, this.noteId = (t == null ? void 0 : t.id) ?? 0;
+  }
+  get attrId() {
+    return this._attrId;
+  }
+  set attrId(t) {
+    var s;
+    t !== this._attrId && (this._attrId = t, t !== ((s = this.attr) == null ? void 0 : s.id) && (this._attr = null), this.isClean && this.dirty());
+  }
+  get attr() {
+    return this._attr;
+  }
+  set attr(t) {
+    const s = this._attr;
+    this._attr = t, t ? (!s || t.type != s.type) && (this.value = t.defaultValue) : this.value = null, this.attrId = (t == null ? void 0 : t.id) ?? 0;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(t) {
+    t != this._value && (this._value = t, this.isClean && this.dirty());
+  }
+  get tagId() {
+    return this._tagId;
+  }
+  set tagId(t) {
+    var s;
+    t !== this._tagId && (this._tagId = t, t !== ((s = this.tag) == null ? void 0 : s.id) && (this._tag = null), this.isClean && this.dirty());
+  }
+  get tag() {
+    return this._tag;
+  }
+  set tag(t) {
+    this._tag = t, this.tagId = (t == null ? void 0 : t.id) ?? null;
+  }
+  duplicate() {
+    const t = new at();
+    return t.noteId = this.noteId, t.note = this.note, t.attrId = this.attrId, t.attr = this.attr, t.tagId = this.tagId, t.tag = this.tag, t.value = this.value, t;
+  }
+  validate(t = !1) {
+    let s = null;
+    if (this.noteId <= 0 && !this.isNew ? s = "NoteAttr noteId must be greater than zero" : this.attrId <= 0 && (s = "NoteAttr attrId must be greater than zero"), t && s != null)
+      throw Error(s);
+    return s == null;
+  }
+}
+class ct extends I {
+  constructor() {
+    super(...arguments);
+    h(this, "_noteId", 0);
+    h(this, "_note", null);
+    h(this, "_tagId", 0);
+    h(this, "_tag", null);
+  }
+  get noteId() {
+    return this._noteId;
+  }
+  set noteId(t) {
+    var s;
+    t !== this._noteId && (this._noteId = t, t !== ((s = this.note) == null ? void 0 : s.id) && (this._note = null), this.isClean && this.dirty());
+  }
+  get note() {
+    return this._note;
+  }
+  set note(t) {
+    this._note = t, this.noteId = (t == null ? void 0 : t.id) ?? 0;
+  }
+  get tagId() {
+    return this._tagId;
+  }
+  set tagId(t) {
+    var s;
+    t !== this._tagId && (this._tagId = t, t !== ((s = this.tag) == null ? void 0 : s.id) && (this._tag = null), this.isClean && this.dirty());
+  }
+  get tag() {
+    return this._tag;
+  }
+  set tag(t) {
+    this._tag = t, this.tagId = (t == null ? void 0 : t.id) ?? 0;
+  }
+  get attrs() {
+    return this.note.attrs.filter((t) => t.tagId == this.tagId);
+  }
+  addAttr(t) {
+    if (!this.note)
+      throw new Error("Cannot call addAttr on NoteTag where note property has not been set");
+    const s = this.note.addAttr(t);
+    return s.tag = this.tag, s;
+  }
+  duplicate() {
+    const t = new ct();
+    return t.noteId = this.noteId, t.tagId = this.tagId, t;
+  }
+  validate(t = !1) {
+    let s = null;
+    if (this.noteId <= 0 && !this.isNew ? s = "NoteTag noteId must be greater than zero" : this.tagId <= 0 ? s = "NoteTag tagId must be greater than zero" : this.noteId == this.tagId && (s = "NoteTag cannot link a note to its own tag"), t && s != null)
+      throw Error(s);
+    return s == null;
+  }
+}
+class ut extends I {
+  constructor(t = "") {
+    super();
+    h(this, "_id", 0);
+    h(this, "_name", "");
+    h(this, "_color", null);
+    this._name = t;
+  }
+  get id() {
+    return this._id;
+  }
+  set id(t) {
+    t !== this._id && (this._id = t, this.isClean && this.dirty());
+  }
+  get name() {
+    return this._name;
+  }
+  set name(t) {
+    t !== this._name && (this._name = t, this.isClean && this.dirty());
+  }
+  get color() {
+    return this._color;
+  }
+  set color(t) {
+    t !== this._color && (this._color = t, this.isClean && this.dirty());
+  }
+  duplicate() {
+    const t = new ut();
+    return t.id = this.id, t.name = this.name, t.state = this.state, t;
+  }
+  validate(t = !1) {
+    let s = null;
+    if (!this.isNew && this.id <= 0 ? s = "Tag id must be greater than zero if in non-new state." : !this.name || !/^[a-zA-Z][a-zA-Z0-9 ]*[a-zA-Z0-9]?$/.test(this.name) ? s = "Tag name is invalid, must only contain letters, numbers, and spaces, starting with a letter" : this.color && !/^#?[A-z0-9]{6}$/.test(this.color) && (s = "Tag color is invalid, must be a 6 character hexadecimal."), t && s != null)
+      throw Error(s);
+    return s == null;
+  }
+}
+class qt extends I {
+  constructor() {
+    super(...arguments);
+    h(this, "id", 0);
+    h(this, "_date", /* @__PURE__ */ new Date());
+    h(this, "_text", "");
+    h(this, "_archived", !1);
+    h(this, "_spaceId", 0);
+    h(this, "_space", null);
+    h(this, "_ownTag", null);
+    h(this, "_tags", []);
+    h(this, "_attrs", []);
+  }
+  get date() {
+    return this._date;
+  }
+  set date(t) {
+    t !== this._date && (this._date = t, this.isClean && this.dirty());
+  }
+  get text() {
+    return this._text;
+  }
+  set text(t) {
+    t !== this._text && (this._text = t, this.isClean && this.dirty());
+  }
+  get archived() {
+    return this._archived;
+  }
+  set archived(t) {
+    t !== this._archived && (this._archived = t, this.isClean && this.dirty());
+  }
+  get spaceId() {
+    return this._spaceId;
+  }
+  set spaceId(t) {
+    var s;
+    t !== this._spaceId && (this._spaceId = t, t !== ((s = this.space) == null ? void 0 : s.id) && (this._space = null), this.isClean && this.dirty());
+  }
+  get space() {
+    return this._space;
+  }
+  set space(t) {
+    this._space = t, this.spaceId = (t == null ? void 0 : t.id) ?? 0;
+  }
+  get ownTag() {
+    return this._ownTag;
+  }
+  setOwnTag(t) {
+    if (typeof t == "string")
+      this.ownTag == null && (this._ownTag = new ut()), this.ownTag.name = t, this.ownTag.id = this.id;
+    else {
+      if (this.ownTag)
+        throw new Error("Note has already had its tag set. If you would like to change the tag name, call setTag with just a string specifying the new tag name.");
+      if (t.id != 0 && t.id != this.id)
+        throw new Error("Attempted to set tag to note with non-matching ID. Added tag id must either match the note id, which indicates that the tag has already been added to the note. Otherwise the tag id must be zero, indicating that the tag still needs to be added.");
+      this._ownTag = t;
+    }
+    return this;
+  }
+  removeOwnTag() {
+    this.ownTag && (this.ownTag.isNew ? this._ownTag = null : this.ownTag.delete());
+  }
+  get tags() {
+    return this._tags;
+  }
+  addTag(t) {
+    if (t.isDeleted)
+      throw Error("Cannot add a tag marked as deleted to a note");
+    if (t.isNew)
+      throw Error("Cannot add a tag that hasn't yet been saved to a note");
+    if (t.id == this.id)
+      throw Error("Note cannot add its own tag as a linked tag");
+    let s = this.tags.find((r) => r.tagId == t.id);
+    return s ? (s.isDeleted && s.dirty(), s) : (s = new ct(), s.note = this, s.tag = t, this._tags.push(s), s);
+  }
+  removeTag(t) {
+    const s = this.tags.find((r) => r.tagId == t.id);
+    return s ? (s.isNew ? this._tags = this._tags.filter((r) => r !== s) : s.delete(), this) : this;
+  }
+  get attrs() {
+    return this._attrs;
+  }
+  addAttr(t) {
+    if (t.isDeleted)
+      throw Error("Cannot add an attribute marked as deleted to a note");
+    if (t.isNew)
+      throw Error("Cannot add an attribute that hasn't yet been saved to a note");
+    let s = this.attrs.find((r) => r.attrId == t.id);
+    return s ? (s.isDeleted && s.dirty(), s) : (s = new at(), s.note = this, s.attr = t, this._attrs.push(s), s);
+  }
+  removeAttr(t) {
+    const s = this.attrs.find((r) => r.attrId == t.id);
+    return s ? (s.isNew ? this._attrs = this._attrs.filter((r) => r !== s) : s.delete(), this) : this;
+  }
+  duplicate() {
+    const t = new qt();
+    return t.id = this.id, t.date = this.date, t.text = this.text, t.archived = this.archived, t.space = this.space, t.state = this.state, t;
+  }
+  validate(t = !1) {
+    let s = null;
+    if (this.spaceId <= 0 ? s = "Note spaceId must be greater than zero." : !this.isNew && this.id <= 0 && (s = "Note id must be greater than zero if in non-new state."), t && s != null)
+      throw Error(s);
+    if (this.ownTag && !this.ownTag.validate(t))
+      return !1;
+    for (const r of this.tags)
+      if (!r.validate(t))
+        return !1;
+    for (const r of this.attrs)
+      if (!r.validate(t))
+        return !1;
+    return s == null;
+  }
+}
+class $t {
+  constructor() {
+    h(this, "where", null);
+    h(this, "order", null);
+    h(this, "tags", []);
+    h(this, "attrs", []);
+  }
+}
+class hn {
+  constructor() {
+    h(this, "space", null);
+    h(this, "name", null);
+    h(this, "searchDepth", 0);
+    h(this, "strictSearchDepth", !0);
+    h(this, "includeOwner", !1);
+  }
+}
+class fn {
+  constructor() {
+    h(this, "space", null);
+    h(this, "name", null);
+    h(this, "exists", !1);
+    h(this, "tagNameFilters", null);
+  }
+}
+function yn(e) {
+  const n = pn(e);
+  return n.where = tt(n.where, n), n.order = tt(n.order, n), n.where = _t(n.where, n), n.order = _t(n.order, n), n;
+}
+function pn(e) {
+  e = " " + e + " ";
+  const n = new $t(), t = e.toUpperCase().indexOf(" ORDER BY ");
+  return t < 0 ? n.where = e.trim() : (n.where = e.substring(0, t).trim(), n.order = e.substring(t + 10).trim()), n.where == "" && (n.where = null), n;
+}
+function tt(e, n) {
+  const t = [
+    /(#+\??~?|~)([\w\d]+\.)?([\w\d]+)/,
+    //Single word tags and space names
+    /(#+\??~?|~)\[([\w\d\s]+\.)?([\w\d\s]+)\]/
+    //Multi-word tags and space names wrapped in []
+  ];
+  for (const s of t)
+    for (; ; ) {
+      const r = s.exec(e);
+      if (!r)
+        break;
+      const i = r[1], o = new hn();
+      o.space = r[2] ? r[2].substring(0, r[2].length - 1) : null, o.name = r[3], o.includeOwner = i.includes("~"), o.searchDepth = (i.match(/#/g) || []).length, o.strictSearchDepth = !i.includes("?");
+      const c = r[0], d = e.indexOf(c), f = d + c.length;
+      e = e.substring(0, d) + `{tag${n.tags.length}}` + e.substring(f), n.tags.push(o);
+    }
+  return e;
+}
+function _t(e, n) {
+  const t = [
+    /@([\w\d]+\.(?!Exists\(|On\())?([\w\d]+)/,
+    /@\[([\w\d\s]+\.)?([\w\d\s]+)\]/
+  ];
+  for (const s of t)
+    for (; ; ) {
+      const r = s.exec(e);
+      if (!r)
+        break;
+      const i = new fn();
+      i.space = r[1] ? r[1].substring(0, r[1].length - 1) : null, i.name = r[2];
+      const o = e.indexOf(r[0]);
+      let c = o + r[0].length;
+      if (e.substring(c, c + 9) == ".Exists()" && (i.exists = !0, c += 9), e.substring(c, c + 4) == ".On(") {
+        let d = c + 4;
+        if (c = e.indexOf(")", d), c < 0)
+          throw Error("Unclosed bracket detected");
+        let f = e.substring(d, c).split("|");
+        const u = new $t();
+        for (let p of f)
+          p.startsWith("~") || (p = "~" + p), tt(p, u);
+        i.tagNameFilters = u.tags, c++;
+      }
+      e = e.substring(0, o) + `{attr${n.attrs.length}}` + e.substring(c), n.attrs.push(i);
+    }
+  return e;
+}
+class Vt extends I {
+  constructor(t = "") {
+    super();
+    h(this, "id", 0);
+    h(this, "_name", "");
+    this._name = t;
+  }
+  get name() {
+    return this._name;
+  }
+  set name(t) {
+    t !== this._name && (this._name = t, this.isClean && this.dirty());
+  }
+  duplicate() {
+    const t = new Vt();
+    return t.id = this.id, t.name = this.name, t.state = this.state, t;
+  }
+  validate(t = !1) {
+    let s = null;
+    if (!this.isNew && this.id <= 0 && (s = "Space id must be greater than zero if in non-new state."), t && s != null)
+      throw Error(s);
+    return s == null;
+  }
+}
+export {
+  Rt as Attr,
+  gn as Environment,
+  wn as HttpClient,
+  qt as Note,
+  at as NoteAttr,
+  ct as NoteTag,
+  Vt as Space,
+  ut as Tag,
+  yn as parseQuery
+};