@hkyhy/marsun-components-core 0.1.18 → 0.1.19

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/node_modules/axios/index.js

@@ -0,0 +1,41 @@
+import o from "./lib/axios.js";
+const {
+  Axios: e,
+  AxiosError: a,
+  CanceledError: t,
+  isCancel: s,
+  CancelToken: i,
+  VERSION: l,
+  all: n,
+  Cancel: c,
+  isAxiosError: d,
+  spread: x,
+  toFormData: C,
+  AxiosHeaders: m,
+  HttpStatusCode: p,
+  formToJSON: A,
+  getAdapter: f,
+  mergeConfig: E,
+  create: g
+} = o;
+export {
+  e as Axios,
+  a as AxiosError,
+  m as AxiosHeaders,
+  c as Cancel,
+  i as CancelToken,
+  t as CanceledError,
+  p as HttpStatusCode,
+  l as VERSION,
+  n as all,
+  g as create,
+  o as default,
+  A as formToJSON,
+  f as getAdapter,
+  d as isAxiosError,
+  s as isCancel,
+  E as mergeConfig,
+  x as spread,
+  C as toFormData
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/axios/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../node_modules/axios/index.js"],"sourcesContent":["import axios from './lib/axios.js';\n\n// This module is intended to unwrap Axios default export as named.\n// Keep top-level export same with static properties\n// so that it can keep same with es module or cjs\nconst {\n  Axios,\n  AxiosError,\n  CanceledError,\n  isCancel,\n  CancelToken,\n  VERSION,\n  all,\n  Cancel,\n  isAxiosError,\n  spread,\n  toFormData,\n  AxiosHeaders,\n  HttpStatusCode,\n  formToJSON,\n  getAdapter,\n  mergeConfig,\n  create,\n} = axios;\n\nexport {\n  axios as default,\n  create,\n  Axios,\n  AxiosError,\n  CanceledError,\n  isCancel,\n  CancelToken,\n  VERSION,\n  all,\n  Cancel,\n  isAxiosError,\n  spread,\n  toFormData,\n  AxiosHeaders,\n  HttpStatusCode,\n  formToJSON,\n  getAdapter,\n  mergeConfig,\n};\n"],"names":["Axios","AxiosError","CanceledError","isCancel","CancelToken","VERSION","all","Cancel","isAxiosError","spread","toFormData","AxiosHeaders","HttpStatusCode","formToJSON","getAdapter","mergeConfig","create","axios"],"mappings":";AAKK,MAAC;AAAA,EACJ,OAAAA;AAAA,EACA,YAAAC;AAAA,EACA,eAAAC;AAAA,EACA,UAAAC;AAAA,EACA,aAAAC;AAAA,EACA,SAAAC;AAAA,EACA,KAAAC;AAAA,EACA,QAAAC;AAAA,EACA,cAAAC;AAAA,EACA,QAAAC;AAAA,EACA,YAAAC;AAAA,EACA,cAAAC;AAAA,EACA,gBAAAC;AAAA,EACA,YAAAC;AAAA,EACA,YAAAC;AAAA,EACA,aAAAC;AAAA,EACA,QAAAC;AACF,IAAIC;","x_google_ignoreList":[0]}

package/dist/node_modules/axios/lib/adapters/adapters.js

@@ -0,0 +1,66 @@
+import s from "../utils.js";
+import m from "../helpers/null.js";
+import u from "./xhr.js";
+import { getFetch as _ } from "./fetch.js";
+import p from "../core/AxiosError.js";
+const c = {
+  http: m,
+  xhr: u,
+  fetch: {
+    get: _
+  }
+};
+s.forEach(c, (e, o) => {
+  if (e) {
+    try {
+      Object.defineProperty(e, "name", { __proto__: null, value: o });
+    } catch {
+    }
+    Object.defineProperty(e, "adapterName", { __proto__: null, value: o });
+  }
+});
+const d = (e) => `- ${e}`, b = (e) => s.isFunction(e) || e === null || e === !1;
+function g(e, o) {
+  e = s.isArray(e) ? e : [e];
+  const { length: a } = e;
+  let i, t;
+  const l = {};
+  for (let r = 0; r < a; r++) {
+    i = e[r];
+    let n;
+    if (t = i, !b(i) && (t = c[(n = String(i)).toLowerCase()], t === void 0))
+      throw new p(`Unknown adapter '${n}'`);
+    if (t && (s.isFunction(t) || (t = t.get(o))))
+      break;
+    l[n || "#" + r] = t;
+  }
+  if (!t) {
+    const r = Object.entries(l).map(
+      ([f, h]) => `adapter ${f} ` + (h === !1 ? "is not supported by the environment" : "is not available in the build")
+    );
+    let n = a ? r.length > 1 ? `since :
+` + r.map(d).join(`
+`) : " " + d(r[0]) : "as no adapter specified";
+    throw new p(
+      "There is no suitable adapter to dispatch the request " + n,
+      p.ERR_NOT_SUPPORT
+    );
+  }
+  return t;
+}
+const y = {
+  /**
+   * Resolve an adapter from a list of adapter names or functions.
+   * @type {Function}
+   */
+  getAdapter: g,
+  /**
+   * Exposes all known adapters
+   * @type {Object<string, Function|Object>}
+   */
+  adapters: c
+};
+export {
+  y as default
+};
+//# sourceMappingURL=adapters.js.map

package/dist/node_modules/axios/lib/adapters/adapters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.js","sources":["../../../../../node_modules/axios/lib/adapters/adapters.js"],"sourcesContent":["import utils from '../utils.js';\nimport httpAdapter from './http.js';\nimport xhrAdapter from './xhr.js';\nimport * as fetchAdapter from './fetch.js';\nimport AxiosError from '../core/AxiosError.js';\n\n/**\n * Known adapters mapping.\n * Provides environment-specific adapters for Axios:\n * - `http` for Node.js\n * - `xhr` for browsers\n * - `fetch` for fetch API-based requests\n *\n * @type {Object<string, Function|Object>}\n */\nconst knownAdapters = {\n  http: httpAdapter,\n  xhr: xhrAdapter,\n  fetch: {\n    get: fetchAdapter.getFetch,\n  },\n};\n\n// Assign adapter names for easier debugging and identification\nutils.forEach(knownAdapters, (fn, value) => {\n  if (fn) {\n    try {\n      // Null-proto descriptors so a polluted Object.prototype.get cannot turn\n      // these data descriptors into accessor descriptors on the way in.\n      Object.defineProperty(fn, 'name', { __proto__: null, value });\n    } catch (e) {\n      // eslint-disable-next-line no-empty\n    }\n    Object.defineProperty(fn, 'adapterName', { __proto__: null, value });\n  }\n});\n\n/**\n * Render a rejection reason string for unknown or unsupported adapters\n *\n * @param {string} reason\n * @returns {string}\n */\nconst renderReason = (reason) => `- ${reason}`;\n\n/**\n * Check if the adapter is resolved (function, null, or false)\n *\n * @param {Function|null|false} adapter\n * @returns {boolean}\n */\nconst isResolvedHandle = (adapter) =>\n  utils.isFunction(adapter) || adapter === null || adapter === false;\n\n/**\n * Get the first suitable adapter from the provided list.\n * Tries each adapter in order until a supported one is found.\n * Throws an AxiosError if no adapter is suitable.\n *\n * @param {Array<string|Function>|string|Function} adapters - Adapter(s) by name or function.\n * @param {Object} config - Axios request configuration\n * @throws {AxiosError} If no suitable adapter is available\n * @returns {Function} The resolved adapter function\n */\nfunction getAdapter(adapters, config) {\n  adapters = utils.isArray(adapters) ? adapters : [adapters];\n\n  const { length } = adapters;\n  let nameOrAdapter;\n  let adapter;\n\n  const rejectedReasons = {};\n\n  for (let i = 0; i < length; i++) {\n    nameOrAdapter = adapters[i];\n    let id;\n\n    adapter = nameOrAdapter;\n\n    if (!isResolvedHandle(nameOrAdapter)) {\n      adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];\n\n      if (adapter === undefined) {\n        throw new AxiosError(`Unknown adapter '${id}'`);\n      }\n    }\n\n    if (adapter && (utils.isFunction(adapter) || (adapter = adapter.get(config)))) {\n      break;\n    }\n\n    rejectedReasons[id || '#' + i] = adapter;\n  }\n\n  if (!adapter) {\n    const reasons = Object.entries(rejectedReasons).map(\n      ([id, state]) =>\n        `adapter ${id} ` +\n        (state === false ? 'is not supported by the environment' : 'is not available in the build')\n    );\n\n    let s = length\n      ? reasons.length > 1\n        ? 'since :\\n' + reasons.map(renderReason).join('\\n')\n        : ' ' + renderReason(reasons[0])\n      : 'as no adapter specified';\n\n    throw new AxiosError(\n      `There is no suitable adapter to dispatch the request ` + s,\n      AxiosError.ERR_NOT_SUPPORT\n    );\n  }\n\n  return adapter;\n}\n\n/**\n * Exports Axios adapters and utility to resolve an adapter\n */\nexport default {\n  /**\n   * Resolve an adapter from a list of adapter names or functions.\n   * @type {Function}\n   */\n  getAdapter,\n\n  /**\n   * Exposes all known adapters\n   * @type {Object<string, Function|Object>}\n   */\n  adapters: knownAdapters,\n};\n"],"names":["knownAdapters","httpAdapter","xhrAdapter","fetchAdapter.getFetch","utils","fn","value","renderReason","reason","isResolvedHandle","adapter","getAdapter","adapters","config","length","nameOrAdapter","rejectedReasons","i","id","AxiosError","reasons","state","s"],"mappings":";;;;;AAeA,MAAMA,IAAgB;AAAA,EACpB,MAAMC;AAAA,EACN,KAAKC;AAAA,EACL,OAAO;AAAA,IACL,KAAKC;AAAAA,EACT;AACA;AAGAC,EAAM,QAAQJ,GAAe,CAACK,GAAIC,MAAU;AAC1C,MAAID,GAAI;AACN,QAAI;AAGF,aAAO,eAAeA,GAAI,QAAQ,EAAE,WAAW,MAAM,OAAAC,GAAO;AAAA,IAC9D,QAAY;AAAA,IAEZ;AACA,WAAO,eAAeD,GAAI,eAAe,EAAE,WAAW,MAAM,OAAAC,GAAO;AAAA,EACrE;AACF,CAAC;AAQD,MAAMC,IAAe,CAACC,MAAW,KAAKA,CAAM,IAQtCC,IAAmB,CAACC,MACxBN,EAAM,WAAWM,CAAO,KAAKA,MAAY,QAAQA,MAAY;AAY/D,SAASC,EAAWC,GAAUC,GAAQ;AACpC,EAAAD,IAAWR,EAAM,QAAQQ,CAAQ,IAAIA,IAAW,CAACA,CAAQ;AAEzD,QAAM,EAAE,QAAAE,EAAM,IAAKF;AACnB,MAAIG,GACAL;AAEJ,QAAMM,IAAkB,CAAA;AAExB,WAASC,IAAI,GAAGA,IAAIH,GAAQG,KAAK;AAC/B,IAAAF,IAAgBH,EAASK,CAAC;AAC1B,QAAIC;AAIJ,QAFAR,IAAUK,GAEN,CAACN,EAAiBM,CAAa,MACjCL,IAAUV,GAAekB,IAAK,OAAOH,CAAa,GAAG,aAAa,GAE9DL,MAAY;AACd,YAAM,IAAIS,EAAW,oBAAoBD,CAAE,GAAG;AAIlD,QAAIR,MAAYN,EAAM,WAAWM,CAAO,MAAMA,IAAUA,EAAQ,IAAIG,CAAM;AACxE;AAGF,IAAAG,EAAgBE,KAAM,MAAMD,CAAC,IAAIP;AAAA,EACnC;AAEA,MAAI,CAACA,GAAS;AACZ,UAAMU,IAAU,OAAO,QAAQJ,CAAe,EAAE;AAAA,MAC9C,CAAC,CAACE,GAAIG,CAAK,MACT,WAAWH,CAAE,OACZG,MAAU,KAAQ,wCAAwC;AAAA,IACnE;AAEI,QAAIC,IAAIR,IACJM,EAAQ,SAAS,IACf;AAAA,IAAcA,EAAQ,IAAIb,CAAY,EAAE,KAAK;AAAA,CAAI,IACjD,MAAMA,EAAaa,EAAQ,CAAC,CAAC,IAC/B;AAEJ,UAAM,IAAID;AAAA,MACR,0DAA0DG;AAAA,MAC1DH,EAAW;AAAA,IACjB;AAAA,EACE;AAEA,SAAOT;AACT;AAKA,MAAAE,IAAe;AAAA;AAAA;AAAA;AAAA;AAAA,EAKb,YAAAD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,UAAUX;AACZ;","x_google_ignoreList":[0]}

package/dist/node_modules/axios/lib/adapters/fetch.js

@@ -0,0 +1,324 @@
+import W from "../platform/index.js";
+import n from "../utils.js";
+import o from "../core/AxiosError.js";
+import we from "../helpers/composeSignals.js";
+import { trackStream as re } from "../helpers/trackStream.js";
+import ne from "../core/AxiosHeaders.js";
+import { progressEventDecorator as se, progressEventReducer as oe, asyncDecorator as ae } from "../helpers/progressEventReducer.js";
+import Re from "../helpers/resolveConfig.js";
+import ye from "../core/settle.js";
+import be from "../helpers/estimateDataURLDecodedBytes.js";
+import { VERSION as Se } from "../env/data.js";
+import { toByteStringHeaderObject as Ee } from "../helpers/sanitizeHeaderValue.js";
+const ie = 64 * 1024, { isFunction: v } = n, xe = (a) => encodeURIComponent(a).replace(
+  /%([0-9A-F]{2})/gi,
+  (l, f) => String.fromCharCode(parseInt(f, 16))
+), ue = (a) => {
+  if (!n.isString(a))
+    return a;
+  try {
+    return decodeURIComponent(a);
+  } catch {
+    return a;
+  }
+}, ce = (a, ...l) => {
+  try {
+    return !!a(...l);
+  } catch {
+    return !1;
+  }
+}, Le = (a) => {
+  const l = a.indexOf("://");
+  let f = a;
+  return l !== -1 && (f = f.slice(l + 3)), f.includes("@") || f.includes(":");
+}, Ce = (a) => {
+  const l = n.global !== void 0 && n.global !== null ? n.global : globalThis, { ReadableStream: f, TextEncoder: P } = l;
+  a = n.merge.call(
+    {
+      skipUndefined: !0
+    },
+    {
+      Request: l.Request,
+      Response: l.Response
+    },
+    a
+  );
+  const { fetch: q, Request: m, Response: B } = a, y = q ? v(q) : typeof fetch == "function", h = v(m), L = v(B);
+  if (!y)
+    return !1;
+  const C = y && v(f), le = y && (typeof P == "function" ? /* @__PURE__ */ ((e) => (s) => e.encode(s))(new P()) : async (e) => new Uint8Array(await new m(e).arrayBuffer())), V = h && C && ce(() => {
+    let e = !1;
+    const s = new m(W.origin, {
+      body: new f(),
+      method: "POST",
+      get duplex() {
+        return e = !0, "half";
+      }
+    }), u = s.headers.has("Content-Type");
+    return s.body != null && s.body.cancel(), e && !u;
+  }), N = L && C && ce(() => n.isReadableStream(new B("").body)), F = {
+    stream: N && ((e) => e.body)
+  };
+  y && ["text", "arrayBuffer", "blob", "formData", "stream"].forEach((e) => {
+    !F[e] && (F[e] = (s, u) => {
+      let c = s && s[e];
+      if (c)
+        return c.call(s);
+      throw new o(
+        `Response type '${e}' is not supported`,
+        o.ERR_NOT_SUPPORT,
+        u
+      );
+    });
+  });
+  const Q = async (e) => {
+    if (e == null)
+      return 0;
+    if (n.isBlob(e))
+      return e.size;
+    if (n.isSpecCompliantForm(e))
+      return (await new m(W.origin, {
+        method: "POST",
+        body: e
+      }).arrayBuffer()).byteLength;
+    if (n.isArrayBufferView(e) || n.isArrayBuffer(e))
+      return e.byteLength;
+    if (n.isURLSearchParams(e) && (e = e + ""), n.isString(e))
+      return (await le(e)).byteLength;
+  }, de = async (e, s) => {
+    const u = n.toFiniteNumber(e.getContentLength());
+    return u ?? Q(s);
+  };
+  return async (e) => {
+    let {
+      url: s,
+      method: u,
+      data: c,
+      signal: fe,
+      cancelToken: Z,
+      timeout: pe,
+      onDownloadProgress: H,
+      onUploadProgress: j,
+      responseType: b,
+      headers: S,
+      withCredentials: z = "same-origin",
+      fetchOptions: $,
+      maxContentLength: g,
+      maxBodyLength: k
+    } = Re(e);
+    const U = n.isNumber(g) && g > -1, M = n.isNumber(k) && k > -1, me = (r) => n.hasOwnProp(e, r) ? e[r] : void 0;
+    let G = q || fetch;
+    b = b ? (b + "").toLowerCase() : "text";
+    let E = we(
+      [fe, Z && Z.toAbortSignal()],
+      pe
+    ), i = null;
+    const _ = E && E.unsubscribe && (() => {
+      E.unsubscribe();
+    });
+    let O, A = null;
+    const J = () => new o(
+      "Request body larger than maxBodyLength limit",
+      o.ERR_BAD_REQUEST,
+      e,
+      i
+    );
+    try {
+      let r;
+      const p = me("auth");
+      if (p) {
+        const t = n.getSafeProp(p, "username") || "", d = n.getSafeProp(p, "password") || "";
+        r = {
+          username: t,
+          password: d
+        };
+      }
+      if (Le(s)) {
+        const t = new URL(s, W.origin);
+        if (!r && (t.username || t.password)) {
+          const d = ue(t.username), x = ue(t.password);
+          r = {
+            username: d,
+            password: x
+          };
+        }
+        (t.username || t.password) && (t.username = "", t.password = "", s = t.href);
+      }
+      if (r && (S.delete("authorization"), S.set(
+        "Authorization",
+        "Basic " + btoa(xe((r.username || "") + ":" + (r.password || "")))
+      )), U && typeof s == "string" && s.startsWith("data:") && be(s) > g)
+        throw new o(
+          "maxContentLength size of " + g + " exceeded",
+          o.ERR_BAD_RESPONSE,
+          e,
+          i
+        );
+      if (M && u !== "get" && u !== "head") {
+        const t = await Q(c);
+        if (typeof t == "number" && isFinite(t) && (O = t, t > k))
+          throw J();
+      }
+      const I = M && (n.isReadableStream(c) || n.isStream(c)), X = (t, d, x) => re(
+        t,
+        ie,
+        (T) => {
+          if (M && T > k)
+            throw A = J();
+          d && d(T);
+        },
+        x
+      );
+      if (V && u !== "get" && u !== "head" && (j || I)) {
+        if (O = O ?? await de(S, c), O !== 0 || I) {
+          let t = new m(s, {
+            method: "POST",
+            body: c,
+            duplex: "half"
+          }), d;
+          if (n.isFormData(c) && (d = t.headers.get("content-type")) && S.setContentType(d), t.body) {
+            const [x, T] = j && se(
+              O,
+              oe(ae(j))
+            ) || [];
+            c = X(t.body, x, T);
+          }
+        }
+      } else if (I && !h && C && u !== "get" && u !== "head")
+        c = X(c);
+      else if (I && h && !V && u !== "get" && u !== "head")
+        throw new o(
+          "Stream request bodies are not supported by the current fetch implementation",
+          o.ERR_NOT_SUPPORT,
+          e,
+          i
+        );
+      n.isString(z) || (z = z ? "include" : "omit");
+      const he = h && "credentials" in m.prototype;
+      if (n.isFormData(c)) {
+        const t = S.getContentType();
+        t && /^multipart\/form-data/i.test(t) && !/boundary=/i.test(t) && S.delete("content-type");
+      }
+      S.set("User-Agent", "axios/" + Se, !1);
+      const Y = {
+        ...$,
+        signal: E,
+        method: u.toUpperCase(),
+        headers: Ee(S.normalize()),
+        body: c,
+        duplex: "half",
+        credentials: he ? z : void 0
+      };
+      i = h && new m(s, Y);
+      let w = await (h ? G(i, $) : G(s, Y));
+      const ee = ne.from(w.headers);
+      if (U) {
+        const t = n.toFiniteNumber(ee.getContentLength());
+        if (t != null && t > g)
+          throw new o(
+            "maxContentLength size of " + g + " exceeded",
+            o.ERR_BAD_RESPONSE,
+            e,
+            i
+          );
+      }
+      const K = N && (b === "stream" || b === "response");
+      if (N && w.body && (H || U || K && _)) {
+        const t = {};
+        ["status", "statusText", "headers"].forEach((D) => {
+          t[D] = w[D];
+        });
+        const d = n.toFiniteNumber(ee.getContentLength()), [x, T] = H && se(
+          d,
+          oe(ae(H), !0)
+        ) || [];
+        let te = 0;
+        const ge = (D) => {
+          if (U && (te = D, te > g))
+            throw new o(
+              "maxContentLength size of " + g + " exceeded",
+              o.ERR_BAD_RESPONSE,
+              e,
+              i
+            );
+          x && x(D);
+        };
+        w = new B(
+          re(w.body, ie, ge, () => {
+            T && T(), _ && _();
+          }),
+          t
+        );
+      }
+      b = b || "text";
+      let R = await F[n.findKey(F, b) || "text"](
+        w,
+        e
+      );
+      if (U && !N && !K) {
+        let t;
+        if (R != null && (typeof R.byteLength == "number" ? t = R.byteLength : typeof R.size == "number" ? t = R.size : typeof R == "string" && (t = typeof P == "function" ? new P().encode(R).byteLength : R.length)), typeof t == "number" && t > g)
+          throw new o(
+            "maxContentLength size of " + g + " exceeded",
+            o.ERR_BAD_RESPONSE,
+            e,
+            i
+          );
+      }
+      return !K && _ && _(), await new Promise((t, d) => {
+        ye(t, d, {
+          data: R,
+          headers: ne.from(w.headers),
+          status: w.status,
+          statusText: w.statusText,
+          config: e,
+          request: i
+        });
+      });
+    } catch (r) {
+      if (_ && _(), E && E.aborted && E.reason instanceof o) {
+        const p = E.reason;
+        throw p.config = e, i && (p.request = i), r !== p && Object.defineProperty(p, "cause", {
+          __proto__: null,
+          value: r,
+          writable: !0,
+          enumerable: !1,
+          configurable: !0
+        }), p;
+      }
+      if (A)
+        throw i && !A.request && (A.request = i), A;
+      if (r instanceof o)
+        throw i && !r.request && (r.request = i), r;
+      if (r && r.name === "TypeError" && /Load failed|fetch/i.test(r.message)) {
+        const p = new o(
+          "Network Error",
+          o.ERR_NETWORK,
+          e,
+          i,
+          r && r.response
+        );
+        throw Object.defineProperty(p, "cause", {
+          __proto__: null,
+          value: r.cause || r,
+          writable: !0,
+          enumerable: !1,
+          configurable: !0
+        }), p;
+      }
+      throw o.from(r, r && r.code, e, i, r && r.response);
+    }
+  };
+}, _e = /* @__PURE__ */ new Map(), Te = (a) => {
+  let l = a && a.env || {};
+  const { fetch: f, Request: P, Response: q } = l, m = [P, q, f];
+  let B = m.length, y = B, h, L, C = _e;
+  for (; y--; )
+    h = m[y], L = C.get(h), L === void 0 && C.set(h, L = y ? /* @__PURE__ */ new Map() : Ce(l)), C = L;
+  return L;
+};
+Te();
+export {
+  Te as getFetch
+};
+//# sourceMappingURL=fetch.js.map

package/dist/node_modules/axios/lib/adapters/fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.js","sources":["../../../../../node_modules/axios/lib/adapters/fetch.js"],"sourcesContent":["import platform from '../platform/index.js';\nimport utils from '../utils.js';\nimport AxiosError from '../core/AxiosError.js';\nimport composeSignals from '../helpers/composeSignals.js';\nimport { trackStream } from '../helpers/trackStream.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\nimport {\n  progressEventReducer,\n  progressEventDecorator,\n  asyncDecorator,\n} from '../helpers/progressEventReducer.js';\nimport resolveConfig from '../helpers/resolveConfig.js';\nimport settle from '../core/settle.js';\nimport estimateDataURLDecodedBytes from '../helpers/estimateDataURLDecodedBytes.js';\nimport { VERSION } from '../env/data.js';\nimport { toByteStringHeaderObject } from '../helpers/sanitizeHeaderValue.js';\n\nconst DEFAULT_CHUNK_SIZE = 64 * 1024;\n\nconst { isFunction } = utils;\n\n/**\n * Encode a UTF-8 string to a Latin-1 byte string for use with btoa().\n * This is a modern replacement for the deprecated unescape(encodeURIComponent(str)) pattern.\n *\n * @param {string} str The string to encode\n *\n * @returns {string} UTF-8 bytes as a Latin-1 string\n */\nconst encodeUTF8 = (str) =>\n  encodeURIComponent(str).replace(/%([0-9A-F]{2})/gi, (_, hex) =>\n    String.fromCharCode(parseInt(hex, 16))\n  );\n\n// Node's WHATWG URL parser returns `username` and `password` percent-encoded.\n// Decode before composing the `auth` option so credentials such as\n// `my%40email.com:pass` are sent as `my@email.com:pass`. Falls back to the\n// original value for malformed input so a bad encoding never throws.\nconst decodeURIComponentSafe = (value) => {\n  if (!utils.isString(value)) {\n    return value;\n  }\n\n  try {\n    return decodeURIComponent(value);\n  } catch (error) {\n    return value;\n  }\n};\n\nconst test = (fn, ...args) => {\n  try {\n    return !!fn(...args);\n  } catch (e) {\n    return false;\n  }\n};\n\nconst maybeWithAuthCredentials = (url) => {\n  const protocolIndex = url.indexOf('://');\n  let urlToCheck = url;\n  if (protocolIndex !== -1) {\n    urlToCheck = urlToCheck.slice(protocolIndex + 3);\n  }\n  return urlToCheck.includes('@') || urlToCheck.includes(':');\n};\n\nconst factory = (env) => {\n  const globalObject =\n    utils.global !== undefined && utils.global !== null\n      ? utils.global\n      : globalThis;\n  const { ReadableStream, TextEncoder } = globalObject;\n\n  env = utils.merge.call(\n    {\n      skipUndefined: true,\n    },\n    {\n      Request: globalObject.Request,\n      Response: globalObject.Response,\n    },\n    env\n  );\n\n  const { fetch: envFetch, Request, Response } = env;\n  const isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch === 'function';\n  const isRequestSupported = isFunction(Request);\n  const isResponseSupported = isFunction(Response);\n\n  if (!isFetchSupported) {\n    return false;\n  }\n\n  const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream);\n\n  const encodeText =\n    isFetchSupported &&\n    (typeof TextEncoder === 'function'\n      ? (\n          (encoder) => (str) =>\n            encoder.encode(str)\n        )(new TextEncoder())\n      : async (str) => new Uint8Array(await new Request(str).arrayBuffer()));\n\n  const supportsRequestStream =\n    isRequestSupported &&\n    isReadableStreamSupported &&\n    test(() => {\n      let duplexAccessed = false;\n\n      const request = new Request(platform.origin, {\n        body: new ReadableStream(),\n        method: 'POST',\n        get duplex() {\n          duplexAccessed = true;\n          return 'half';\n        },\n      });\n\n      const hasContentType = request.headers.has('Content-Type');\n\n      if (request.body != null) {\n        request.body.cancel();\n      }\n\n      return duplexAccessed && !hasContentType;\n    });\n\n  const supportsResponseStream =\n    isResponseSupported &&\n    isReadableStreamSupported &&\n    test(() => utils.isReadableStream(new Response('').body));\n\n  const resolvers = {\n    stream: supportsResponseStream && ((res) => res.body),\n  };\n\n  isFetchSupported &&\n    (() => {\n      ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach((type) => {\n        !resolvers[type] &&\n          (resolvers[type] = (res, config) => {\n            let method = res && res[type];\n\n            if (method) {\n              return method.call(res);\n            }\n\n            throw new AxiosError(\n              `Response type '${type}' is not supported`,\n              AxiosError.ERR_NOT_SUPPORT,\n              config\n            );\n          });\n      });\n    })();\n\n  const getBodyLength = async (body) => {\n    if (body == null) {\n      return 0;\n    }\n\n    if (utils.isBlob(body)) {\n      return body.size;\n    }\n\n    if (utils.isSpecCompliantForm(body)) {\n      const _request = new Request(platform.origin, {\n        method: 'POST',\n        body,\n      });\n      return (await _request.arrayBuffer()).byteLength;\n    }\n\n    if (utils.isArrayBufferView(body) || utils.isArrayBuffer(body)) {\n      return body.byteLength;\n    }\n\n    if (utils.isURLSearchParams(body)) {\n      body = body + '';\n    }\n\n    if (utils.isString(body)) {\n      return (await encodeText(body)).byteLength;\n    }\n  };\n\n  const resolveBodyLength = async (headers, body) => {\n    const length = utils.toFiniteNumber(headers.getContentLength());\n\n    return length == null ? getBodyLength(body) : length;\n  };\n\n  return async (config) => {\n    let {\n      url,\n      method,\n      data,\n      signal,\n      cancelToken,\n      timeout,\n      onDownloadProgress,\n      onUploadProgress,\n      responseType,\n      headers,\n      withCredentials = 'same-origin',\n      fetchOptions,\n      maxContentLength,\n      maxBodyLength,\n    } = resolveConfig(config);\n\n    const hasMaxContentLength = utils.isNumber(maxContentLength) && maxContentLength > -1;\n    const hasMaxBodyLength = utils.isNumber(maxBodyLength) && maxBodyLength > -1;\n    const own = (key) => (utils.hasOwnProp(config, key) ? config[key] : undefined);\n\n    let _fetch = envFetch || fetch;\n\n    responseType = responseType ? (responseType + '').toLowerCase() : 'text';\n\n    let composedSignal = composeSignals(\n      [signal, cancelToken && cancelToken.toAbortSignal()],\n      timeout\n    );\n\n    let request = null;\n\n    const unsubscribe =\n      composedSignal &&\n      composedSignal.unsubscribe &&\n      (() => {\n        composedSignal.unsubscribe();\n      });\n\n    let requestContentLength;\n\n    // AxiosError we raise while the request body is being streamed. Captured\n    // by identity so the catch block can surface it directly, regardless of\n    // how the runtime wraps the resulting fetch rejection (undici exposes it\n    // as `err.cause`; some browsers drop the original error entirely).\n    let pendingBodyError = null;\n\n    const maxBodyLengthError = () =>\n      new AxiosError(\n        'Request body larger than maxBodyLength limit',\n        AxiosError.ERR_BAD_REQUEST,\n        config,\n        request\n      );\n\n    try {\n      // HTTP basic authentication\n      let auth = undefined;\n      const configAuth = own('auth');\n\n      if (configAuth) {\n        const username = utils.getSafeProp(configAuth, 'username') || '';\n        const password = utils.getSafeProp(configAuth, 'password') || '';\n        auth = {\n          username,\n          password\n        };\n      }\n\n      if (maybeWithAuthCredentials(url)) {\n        const parsedURL = new URL(url, platform.origin);\n\n        if (!auth && (parsedURL.username || parsedURL.password)) {\n          const urlUsername = decodeURIComponentSafe(parsedURL.username);\n          const urlPassword = decodeURIComponentSafe(parsedURL.password);\n          auth = {\n            username: urlUsername,\n            password: urlPassword\n          };\n        }\n\n        if (parsedURL.username || parsedURL.password) {\n          parsedURL.username = '';\n          parsedURL.password = '';\n          url = parsedURL.href;\n        }\n      }\n\n      if (auth) {\n        headers.delete('authorization');\n        headers.set(\n          'Authorization',\n          'Basic ' + btoa(encodeUTF8((auth.username || '') + ':' + (auth.password || '')))\n        );\n      }\n\n      // Enforce maxContentLength for data: URLs up-front so we never materialize\n      // an oversized payload. The HTTP adapter applies the same check (see http.js\n      // \"if (protocol === 'data:')\" branch).\n      if (hasMaxContentLength && typeof url === 'string' && url.startsWith('data:')) {\n        const estimated = estimateDataURLDecodedBytes(url);\n        if (estimated > maxContentLength) {\n          throw new AxiosError(\n            'maxContentLength size of ' + maxContentLength + ' exceeded',\n            AxiosError.ERR_BAD_RESPONSE,\n            config,\n            request\n          );\n        }\n      }\n\n      // Enforce maxBodyLength against known-size bodies before dispatch using\n      // the body's *actual* size — never a caller-declared Content-Length,\n      // which could under-report to slip an oversized body past the check.\n      // Unknown-size streams return undefined here and are counted per-chunk\n      // below as fetch consumes them.\n      if (hasMaxBodyLength && method !== 'get' && method !== 'head') {\n        const outboundLength = await getBodyLength(data);\n        if (typeof outboundLength === 'number' && isFinite(outboundLength)) {\n          requestContentLength = outboundLength;\n          if (outboundLength > maxBodyLength) {\n            throw maxBodyLengthError();\n          }\n        }\n      }\n\n      // A streamed body under maxBodyLength must be counted as fetch consumes\n      // it; its size is never trusted from a caller-declared Content-Length.\n      const mustEnforceStreamBody =\n        hasMaxBodyLength && (utils.isReadableStream(data) || utils.isStream(data));\n\n      const trackRequestStream = (stream, onProgress, flush) =>\n        trackStream(\n          stream,\n          DEFAULT_CHUNK_SIZE,\n          (loadedBytes) => {\n            if (hasMaxBodyLength && loadedBytes > maxBodyLength) {\n              throw (pendingBodyError = maxBodyLengthError());\n            }\n            onProgress && onProgress(loadedBytes);\n          },\n          flush\n        );\n\n      if (\n        supportsRequestStream &&\n        method !== 'get' &&\n        method !== 'head' &&\n        (onUploadProgress || mustEnforceStreamBody)\n      ) {\n        requestContentLength =\n          requestContentLength == null ? await resolveBodyLength(headers, data) : requestContentLength;\n\n        // A declared length of 0 is only trusted to skip the wrap when we are\n        // not enforcing a stream limit (which must not rely on that header).\n        if (requestContentLength !== 0 || mustEnforceStreamBody) {\n          let _request = new Request(url, {\n            method: 'POST',\n            body: data,\n            duplex: 'half',\n          });\n\n          let contentTypeHeader;\n\n          if (utils.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {\n            headers.setContentType(contentTypeHeader);\n          }\n\n          if (_request.body) {\n            const [onProgress, flush] =\n              (onUploadProgress &&\n                progressEventDecorator(\n                  requestContentLength,\n                  progressEventReducer(asyncDecorator(onUploadProgress))\n                )) ||\n              [];\n\n            data = trackRequestStream(_request.body, onProgress, flush);\n          }\n        }\n      } else if (\n        mustEnforceStreamBody &&\n        !isRequestSupported &&\n        isReadableStreamSupported &&\n        method !== 'get' &&\n        method !== 'head'\n      ) {\n        data = trackRequestStream(data);\n      } else if (\n        mustEnforceStreamBody &&\n        isRequestSupported &&\n        !supportsRequestStream &&\n        method !== 'get' &&\n        method !== 'head'\n      ) {\n        throw new AxiosError(\n          'Stream request bodies are not supported by the current fetch implementation',\n          AxiosError.ERR_NOT_SUPPORT,\n          config,\n          request\n        );\n      }\n\n      if (!utils.isString(withCredentials)) {\n        withCredentials = withCredentials ? 'include' : 'omit';\n      }\n\n      // Cloudflare Workers throws when credentials are defined\n      // see https://github.com/cloudflare/workerd/issues/902\n      const isCredentialsSupported = isRequestSupported && 'credentials' in Request.prototype;\n\n      // If data is FormData and Content-Type is multipart/form-data without boundary,\n      // delete it so fetch can set it correctly with the boundary\n      if (utils.isFormData(data)) {\n        const contentType = headers.getContentType();\n        if (\n          contentType &&\n          /^multipart\\/form-data/i.test(contentType) &&\n          !/boundary=/i.test(contentType)\n        ) {\n          headers.delete('content-type');\n        }\n      }\n\n      // Set User-Agent header if not already set (fetch defaults to 'node' in Node.js)\n      headers.set('User-Agent', 'axios/' + VERSION, false);\n\n      const resolvedOptions = {\n        ...fetchOptions,\n        signal: composedSignal,\n        method: method.toUpperCase(),\n        headers: toByteStringHeaderObject(headers.normalize()),\n        body: data,\n        duplex: 'half',\n        credentials: isCredentialsSupported ? withCredentials : undefined,\n      };\n\n      request = isRequestSupported && new Request(url, resolvedOptions);\n\n      let response = await (isRequestSupported\n        ? _fetch(request, fetchOptions)\n        : _fetch(url, resolvedOptions));\n\n      const responseHeaders = AxiosHeaders.from(response.headers);\n\n      // Cheap pre-check: if the server honestly declares a content-length that\n      // already exceeds the cap, reject before we start streaming.\n      if (hasMaxContentLength) {\n        const declaredLength = utils.toFiniteNumber(responseHeaders.getContentLength());\n        if (declaredLength != null && declaredLength > maxContentLength) {\n          throw new AxiosError(\n            'maxContentLength size of ' + maxContentLength + ' exceeded',\n            AxiosError.ERR_BAD_RESPONSE,\n            config,\n            request\n          );\n        }\n      }\n\n      const isStreamResponse =\n        supportsResponseStream && (responseType === 'stream' || responseType === 'response');\n\n      if (\n        supportsResponseStream &&\n        response.body &&\n        (onDownloadProgress || hasMaxContentLength || (isStreamResponse && unsubscribe))\n      ) {\n        const options = {};\n\n        ['status', 'statusText', 'headers'].forEach((prop) => {\n          options[prop] = response[prop];\n        });\n\n        const responseContentLength = utils.toFiniteNumber(responseHeaders.getContentLength());\n\n        const [onProgress, flush] =\n          (onDownloadProgress &&\n            progressEventDecorator(\n              responseContentLength,\n              progressEventReducer(asyncDecorator(onDownloadProgress), true)\n            )) ||\n          [];\n\n        let bytesRead = 0;\n        const onChunkProgress = (loadedBytes) => {\n          if (hasMaxContentLength) {\n            bytesRead = loadedBytes;\n            if (bytesRead > maxContentLength) {\n              throw new AxiosError(\n                'maxContentLength size of ' + maxContentLength + ' exceeded',\n                AxiosError.ERR_BAD_RESPONSE,\n                config,\n                request\n              );\n            }\n          }\n          onProgress && onProgress(loadedBytes);\n        };\n\n        response = new Response(\n          trackStream(response.body, DEFAULT_CHUNK_SIZE, onChunkProgress, () => {\n            flush && flush();\n            unsubscribe && unsubscribe();\n          }),\n          options\n        );\n      }\n\n      responseType = responseType || 'text';\n\n      let responseData = await resolvers[utils.findKey(resolvers, responseType) || 'text'](\n        response,\n        config\n      );\n\n      // Fallback enforcement for environments without ReadableStream support\n      // (legacy runtimes). Detect materialized size from typed output; skip\n      // streams/Response passthrough since the user will read those themselves.\n      if (hasMaxContentLength && !supportsResponseStream && !isStreamResponse) {\n        let materializedSize;\n        if (responseData != null) {\n          if (typeof responseData.byteLength === 'number') {\n            materializedSize = responseData.byteLength;\n          } else if (typeof responseData.size === 'number') {\n            materializedSize = responseData.size;\n          } else if (typeof responseData === 'string') {\n            materializedSize =\n              typeof TextEncoder === 'function'\n                ? new TextEncoder().encode(responseData).byteLength\n                : responseData.length;\n          }\n        }\n        if (typeof materializedSize === 'number' && materializedSize > maxContentLength) {\n          throw new AxiosError(\n            'maxContentLength size of ' + maxContentLength + ' exceeded',\n            AxiosError.ERR_BAD_RESPONSE,\n            config,\n            request\n          );\n        }\n      }\n\n      !isStreamResponse && unsubscribe && unsubscribe();\n\n      return await new Promise((resolve, reject) => {\n        settle(resolve, reject, {\n          data: responseData,\n          headers: AxiosHeaders.from(response.headers),\n          status: response.status,\n          statusText: response.statusText,\n          config,\n          request,\n        });\n      });\n    } catch (err) {\n      unsubscribe && unsubscribe();\n\n      // Safari can surface fetch aborts as a DOMException-like object whose\n      // branded getters throw. Prefer our composed signal reason before reading\n      // the caught error, preserving timeout vs cancellation semantics.\n      if (composedSignal && composedSignal.aborted && composedSignal.reason instanceof AxiosError) {\n        const canceledError = composedSignal.reason;\n        canceledError.config = config;\n        request && (canceledError.request = request);\n        if (err !== canceledError) {\n          // Non-enumerable to match native Error `cause` semantics so loggers\n          // don't recurse into circular fetch internals (see #7205).\n          Object.defineProperty(canceledError, 'cause', {\n            __proto__: null,\n            value: err,\n            writable: true,\n            enumerable: false,\n            configurable: true,\n          });\n        }\n        throw canceledError;\n      }\n\n      // Surface a maxBodyLength violation we raised while the request body was\n      // being streamed. Matching by identity (rather than reading\n      // `err.cause.isAxiosError`) keeps the error deterministic across runtimes\n      // and avoids both prototype-pollution reads and mis-attributing a foreign\n      // AxiosError that merely happened to land in `err.cause`.\n      if (pendingBodyError) {\n        request && !pendingBodyError.request && (pendingBodyError.request = request);\n        throw pendingBodyError;\n      }\n\n      // Re-throw AxiosErrors we raised synchronously (data: URL / content-length\n      // pre-checks, response size enforcement) without re-wrapping them.\n      if (err instanceof AxiosError) {\n        request && !err.request && (err.request = request);\n        throw err;\n      }\n\n      if (err && err.name === 'TypeError' && /Load failed|fetch/i.test(err.message)) {\n        const networkError = new AxiosError(\n          'Network Error',\n          AxiosError.ERR_NETWORK,\n          config,\n          request,\n          err && err.response\n        );\n        // Non-enumerable to match native Error `cause` semantics so loggers\n        // don't recurse into circular fetch internals (see #7205).\n        Object.defineProperty(networkError, 'cause', {\n          __proto__: null,\n          value: err.cause || err,\n          writable: true,\n          enumerable: false,\n          configurable: true,\n        });\n        throw networkError;\n      }\n\n      throw AxiosError.from(err, err && err.code, config, request, err && err.response);\n    }\n  };\n};\n\nconst seedCache = new Map();\n\nexport const getFetch = (config) => {\n  let env = (config && config.env) || {};\n  const { fetch, Request, Response } = env;\n  const seeds = [Request, Response, fetch];\n\n  let len = seeds.length,\n    i = len,\n    seed,\n    target,\n    map = seedCache;\n\n  while (i--) {\n    seed = seeds[i];\n    target = map.get(seed);\n\n    target === undefined && map.set(seed, (target = i ? new Map() : factory(env)));\n\n    map = target;\n  }\n\n  return target;\n};\n\nconst adapter = getFetch();\n\nexport default adapter;\n"],"names":["DEFAULT_CHUNK_SIZE","isFunction","utils","encodeUTF8","str","_","hex","decodeURIComponentSafe","value","test","fn","args","maybeWithAuthCredentials","url","protocolIndex","urlToCheck","factory","env","globalObject","ReadableStream","TextEncoder","envFetch","Request","Response","isFetchSupported","isRequestSupported","isResponseSupported","isReadableStreamSupported","encodeText","encoder","supportsRequestStream","duplexAccessed","request","platform","hasContentType","supportsResponseStream","resolvers","res","type","config","method","AxiosError","getBodyLength","body","resolveBodyLength","headers","length","data","signal","cancelToken","timeout","onDownloadProgress","onUploadProgress","responseType","withCredentials","fetchOptions","maxContentLength","maxBodyLength","resolveConfig","hasMaxContentLength","hasMaxBodyLength","own","key","_fetch","composedSignal","composeSignals","unsubscribe","requestContentLength","pendingBodyError","maxBodyLengthError","auth","configAuth","username","password","parsedURL","urlUsername","urlPassword","estimateDataURLDecodedBytes","outboundLength","mustEnforceStreamBody","trackRequestStream","stream","onProgress","flush","trackStream","loadedBytes","_request","contentTypeHeader","progressEventDecorator","progressEventReducer","asyncDecorator","isCredentialsSupported","contentType","VERSION","resolvedOptions","toByteStringHeaderObject","response","responseHeaders","AxiosHeaders","declaredLength","isStreamResponse","options","prop","responseContentLength","bytesRead","onChunkProgress","responseData","materializedSize","resolve","reject","settle","err","canceledError","networkError","seedCache","getFetch","fetch","seeds","len","i","seed","target","map"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/axios/lib/adapters/xhr.js

@@ -0,0 +1,86 @@
+import q from "../utils.js";
+import C from "../core/settle.js";
+import D from "../defaults/transitional.js";
+import n from "../core/AxiosError.js";
+import L from "../cancel/CanceledError.js";
+import U from "../helpers/parseProtocol.js";
+import v from "../platform/index.js";
+import x from "../core/AxiosHeaders.js";
+import { progressEventReducer as y } from "../helpers/progressEventReducer.js";
+import O from "../helpers/resolveConfig.js";
+import { toByteStringHeaderObject as k } from "../helpers/sanitizeHeaderValue.js";
+const M = typeof XMLHttpRequest < "u", G = M && function(s) {
+  return new Promise(function(A, l) {
+    const t = O(s);
+    let T = t.data;
+    const R = x.from(t.headers).normalize();
+    let { responseType: d, onUploadProgress: h, onDownloadProgress: g } = t, u, w, b, p, m;
+    function a() {
+      p && p(), m && m(), t.cancelToken && t.cancelToken.unsubscribe(u), t.signal && t.signal.removeEventListener("abort", u);
+    }
+    let e = new XMLHttpRequest();
+    e.open(t.method.toUpperCase(), t.url, !0), e.timeout = t.timeout;
+    function H() {
+      if (!e)
+        return;
+      const o = x.from(
+        "getAllResponseHeaders" in e && e.getAllResponseHeaders()
+      ), i = {
+        data: !d || d === "text" || d === "json" ? e.responseText : e.response,
+        status: e.status,
+        statusText: e.statusText,
+        headers: o,
+        config: s,
+        request: e
+      };
+      C(
+        function(E) {
+          A(E), a();
+        },
+        function(E) {
+          l(E), a();
+        },
+        i
+      ), e = null;
+    }
+    "onloadend" in e ? e.onloadend = H : e.onreadystatechange = function() {
+      !e || e.readyState !== 4 || e.status === 0 && !(e.responseURL && e.responseURL.startsWith("file:")) || setTimeout(H);
+    }, e.onabort = function() {
+      e && (l(new n("Request aborted", n.ECONNABORTED, s, e)), a(), e = null);
+    }, e.onerror = function(r) {
+      const i = r && r.message ? r.message : "Network Error", f = new n(i, n.ERR_NETWORK, s, e);
+      f.event = r || null, l(f), a(), e = null;
+    }, e.ontimeout = function() {
+      let r = t.timeout ? "timeout of " + t.timeout + "ms exceeded" : "timeout exceeded";
+      const i = t.transitional || D;
+      t.timeoutErrorMessage && (r = t.timeoutErrorMessage), l(
+        new n(
+          r,
+          i.clarifyTimeoutError ? n.ETIMEDOUT : n.ECONNABORTED,
+          s,
+          e
+        )
+      ), a(), e = null;
+    }, T === void 0 && R.setContentType(null), "setRequestHeader" in e && q.forEach(k(R), function(r, i) {
+      e.setRequestHeader(i, r);
+    }), q.isUndefined(t.withCredentials) || (e.withCredentials = !!t.withCredentials), d && d !== "json" && (e.responseType = t.responseType), g && ([b, m] = y(g, !0), e.addEventListener("progress", b)), h && e.upload && ([w, p] = y(h), e.upload.addEventListener("progress", w), e.upload.addEventListener("loadend", p)), (t.cancelToken || t.signal) && (u = (o) => {
+      e && (l(!o || o.type ? new L(null, s, e) : o), e.abort(), a(), e = null);
+    }, t.cancelToken && t.cancelToken.subscribe(u), t.signal && (t.signal.aborted ? u() : t.signal.addEventListener("abort", u)));
+    const c = U(t.url);
+    if (c && !v.protocols.includes(c)) {
+      l(
+        new n(
+          "Unsupported protocol " + c + ":",
+          n.ERR_BAD_REQUEST,
+          s
+        )
+      ), a();
+      return;
+    }
+    e.send(T || null);
+  });
+};
+export {
+  G as default
+};
+//# sourceMappingURL=xhr.js.map

package/dist/node_modules/axios/lib/adapters/xhr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xhr.js","sources":["../../../../../node_modules/axios/lib/adapters/xhr.js"],"sourcesContent":["import utils from '../utils.js';\nimport settle from '../core/settle.js';\nimport transitionalDefaults from '../defaults/transitional.js';\nimport AxiosError from '../core/AxiosError.js';\nimport CanceledError from '../cancel/CanceledError.js';\nimport parseProtocol from '../helpers/parseProtocol.js';\nimport platform from '../platform/index.js';\nimport AxiosHeaders from '../core/AxiosHeaders.js';\nimport { progressEventReducer } from '../helpers/progressEventReducer.js';\nimport resolveConfig from '../helpers/resolveConfig.js';\nimport { toByteStringHeaderObject } from '../helpers/sanitizeHeaderValue.js';\n\nconst isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';\n\nexport default isXHRAdapterSupported &&\n  function (config) {\n    return new Promise(function dispatchXhrRequest(resolve, reject) {\n      const _config = resolveConfig(config);\n      let requestData = _config.data;\n      const requestHeaders = AxiosHeaders.from(_config.headers).normalize();\n      let { responseType, onUploadProgress, onDownloadProgress } = _config;\n      let onCanceled;\n      let uploadThrottled, downloadThrottled;\n      let flushUpload, flushDownload;\n\n      function done() {\n        flushUpload && flushUpload(); // flush events\n        flushDownload && flushDownload(); // flush events\n\n        _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);\n\n        _config.signal && _config.signal.removeEventListener('abort', onCanceled);\n      }\n\n      let request = new XMLHttpRequest();\n\n      request.open(_config.method.toUpperCase(), _config.url, true);\n\n      // Set the request timeout in MS\n      request.timeout = _config.timeout;\n\n      function onloadend() {\n        if (!request) {\n          return;\n        }\n        // Prepare the response\n        const responseHeaders = AxiosHeaders.from(\n          'getAllResponseHeaders' in request && request.getAllResponseHeaders()\n        );\n        const responseData =\n          !responseType || responseType === 'text' || responseType === 'json'\n            ? request.responseText\n            : request.response;\n        const response = {\n          data: responseData,\n          status: request.status,\n          statusText: request.statusText,\n          headers: responseHeaders,\n          config,\n          request,\n        };\n\n        settle(\n          function _resolve(value) {\n            resolve(value);\n            done();\n          },\n          function _reject(err) {\n            reject(err);\n            done();\n          },\n          response\n        );\n\n        // Clean up request\n        request = null;\n      }\n\n      if ('onloadend' in request) {\n        // Use onloadend if available\n        request.onloadend = onloadend;\n      } else {\n        // Listen for ready state to emulate onloadend\n        request.onreadystatechange = function handleLoad() {\n          if (!request || request.readyState !== 4) {\n            return;\n          }\n\n          // The request errored out and we didn't get a response, this will be\n          // handled by onerror instead\n          // With one exception: request that using file: protocol, most browsers\n          // will return status as 0 even though it's a successful request\n          if (\n            request.status === 0 &&\n            !(request.responseURL && request.responseURL.startsWith('file:'))\n          ) {\n            return;\n          }\n          // readystate handler is calling before onerror or ontimeout handlers,\n          // so we should call onloadend on the next 'tick'\n          setTimeout(onloadend);\n        };\n      }\n\n      // Handle browser request cancellation (as opposed to a manual cancellation)\n      request.onabort = function handleAbort() {\n        if (!request) {\n          return;\n        }\n\n        reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request));\n        done();\n\n        // Clean up request\n        request = null;\n      };\n\n      // Handle low level network errors\n      request.onerror = function handleError(event) {\n        // Browsers deliver a ProgressEvent in XHR onerror\n        // (message may be empty; when present, surface it)\n        // See https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/error_event\n        const msg = event && event.message ? event.message : 'Network Error';\n        const err = new AxiosError(msg, AxiosError.ERR_NETWORK, config, request);\n        // attach the underlying event for consumers who want details\n        err.event = event || null;\n        reject(err);\n        done();\n        request = null;\n      };\n\n      // Handle timeout\n      request.ontimeout = function handleTimeout() {\n        let timeoutErrorMessage = _config.timeout\n          ? 'timeout of ' + _config.timeout + 'ms exceeded'\n          : 'timeout exceeded';\n        const transitional = _config.transitional || transitionalDefaults;\n        if (_config.timeoutErrorMessage) {\n          timeoutErrorMessage = _config.timeoutErrorMessage;\n        }\n        reject(\n          new AxiosError(\n            timeoutErrorMessage,\n            transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,\n            config,\n            request\n          )\n        );\n        done();\n\n        // Clean up request\n        request = null;\n      };\n\n      // Remove Content-Type if data is undefined\n      requestData === undefined && requestHeaders.setContentType(null);\n\n      // Add headers to the request\n      if ('setRequestHeader' in request) {\n        utils.forEach(toByteStringHeaderObject(requestHeaders), function setRequestHeader(val, key) {\n          request.setRequestHeader(key, val);\n        });\n      }\n\n      // Add withCredentials to request if needed\n      if (!utils.isUndefined(_config.withCredentials)) {\n        request.withCredentials = !!_config.withCredentials;\n      }\n\n      // Add responseType to request if needed\n      if (responseType && responseType !== 'json') {\n        request.responseType = _config.responseType;\n      }\n\n      // Handle progress if needed\n      if (onDownloadProgress) {\n        [downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true);\n        request.addEventListener('progress', downloadThrottled);\n      }\n\n      // Not all browsers support upload events\n      if (onUploadProgress && request.upload) {\n        [uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress);\n\n        request.upload.addEventListener('progress', uploadThrottled);\n\n        request.upload.addEventListener('loadend', flushUpload);\n      }\n\n      if (_config.cancelToken || _config.signal) {\n        // Handle cancellation\n        // eslint-disable-next-line func-names\n        onCanceled = (cancel) => {\n          if (!request) {\n            return;\n          }\n          reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);\n          request.abort();\n          done();\n          request = null;\n        };\n\n        _config.cancelToken && _config.cancelToken.subscribe(onCanceled);\n        if (_config.signal) {\n          _config.signal.aborted\n            ? onCanceled()\n            : _config.signal.addEventListener('abort', onCanceled);\n        }\n      }\n\n      const protocol = parseProtocol(_config.url);\n\n      if (protocol && !platform.protocols.includes(protocol)) {\n        reject(\n          new AxiosError(\n            'Unsupported protocol ' + protocol + ':',\n            AxiosError.ERR_BAD_REQUEST,\n            config\n          )\n        );\n        done();\n        return;\n      }\n\n      // Send the request\n      request.send(requestData || null);\n    });\n  };\n"],"names":["isXHRAdapterSupported","xhrAdapter","config","resolve","reject","_config","resolveConfig","requestData","requestHeaders","AxiosHeaders","responseType","onUploadProgress","onDownloadProgress","onCanceled","uploadThrottled","downloadThrottled","flushUpload","flushDownload","done","request","onloadend","responseHeaders","response","settle","value","err","AxiosError","event","msg","timeoutErrorMessage","transitional","transitionalDefaults","utils","toByteStringHeaderObject","val","key","progressEventReducer","cancel","CanceledError","protocol","parseProtocol","platform"],"mappings":"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","x_google_ignoreList":[0]}