@fecp/mobile 1.0.26 → 1.0.28

package/lib/node_modules/.pnpm/axios@1.8.4/node_modules/axios/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const axios = require("./lib/axios.js");
+const {
+  Axios,
+  AxiosError,
+  CanceledError,
+  isCancel,
+  CancelToken,
+  VERSION,
+  all,
+  Cancel,
+  isAxiosError,
+  spread,
+  toFormData,
+  AxiosHeaders,
+  HttpStatusCode,
+  formToJSON,
+  getAdapter,
+  mergeConfig
+} = axios.default;
+exports.default = axios.default;
+exports.Axios = Axios;
+exports.AxiosError = AxiosError;
+exports.AxiosHeaders = AxiosHeaders;
+exports.Cancel = Cancel;
+exports.CancelToken = CancelToken;
+exports.CanceledError = CanceledError;
+exports.HttpStatusCode = HttpStatusCode;
+exports.VERSION = VERSION;
+exports.all = all;
+exports.formToJSON = formToJSON;
+exports.getAdapter = getAdapter;
+exports.isAxiosError = isAxiosError;
+exports.isCancel = isCancel;
+exports.mergeConfig = mergeConfig;
+exports.spread = spread;
+exports.toFormData = toFormData;

package/lib/node_modules/.pnpm/axios@1.8.4/node_modules/axios/lib/adapters/adapters.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const utils = require("../utils.js");
+const _null = require("../helpers/null.js");
+const xhr = require("./xhr.js");
+const fetch = require("./fetch.js");
+const AxiosError = require("../core/AxiosError.js");
+const knownAdapters = {
+  http: _null.default,
+  xhr: xhr.default,
+  fetch: fetch.default
+};
+utils.default.forEach(knownAdapters, (fn, value) => {
+  if (fn) {
+    try {
+      Object.defineProperty(fn, "name", { value });
+    } catch (e) {
+    }
+    Object.defineProperty(fn, "adapterName", { value });
+  }
+});
+const renderReason = (reason) => `- ${reason}`;
+const isResolvedHandle = (adapter) => utils.default.isFunction(adapter) || adapter === null || adapter === false;
+const adapters = {
+  getAdapter: (adapters2) => {
+    adapters2 = utils.default.isArray(adapters2) ? adapters2 : [adapters2];
+    const { length } = adapters2;
+    let nameOrAdapter;
+    let adapter;
+    const rejectedReasons = {};
+    for (let i = 0; i < length; i++) {
+      nameOrAdapter = adapters2[i];
+      let id;
+      adapter = nameOrAdapter;
+      if (!isResolvedHandle(nameOrAdapter)) {
+        adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
+        if (adapter === void 0) {
+          throw new AxiosError.default(`Unknown adapter '${id}'`);
+        }
+      }
+      if (adapter) {
+        break;
+      }
+      rejectedReasons[id || "#" + i] = adapter;
+    }
+    if (!adapter) {
+      const reasons = Object.entries(rejectedReasons).map(
+        ([id, state]) => `adapter ${id} ` + (state === false ? "is not supported by the environment" : "is not available in the build")
+      );
+      let s = length ? reasons.length > 1 ? "since :\n" + reasons.map(renderReason).join("\n") : " " + renderReason(reasons[0]) : "as no adapter specified";
+      throw new AxiosError.default(
+        `There is no suitable adapter to dispatch the request ` + s,
+        "ERR_NOT_SUPPORT"
+      );
+    }
+    return adapter;
+  },
+  adapters: knownAdapters
+};
+exports.default = adapters;

package/lib/node_modules/.pnpm/axios@1.8.4/node_modules/axios/lib/adapters/fetch.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../platform/index.js");
+const utils = require("../utils.js");
+const AxiosError = require("../core/AxiosError.js");
+const composeSignals = require("../helpers/composeSignals.js");
+const trackStream = require("../helpers/trackStream.js");
+const AxiosHeaders = require("../core/AxiosHeaders.js");
+const progressEventReducer = require("../helpers/progressEventReducer.js");
+const resolveConfig = require("../helpers/resolveConfig.js");
+const settle = require("../core/settle.js");
+const isFetchSupported = typeof fetch === "function" && typeof Request === "function" && typeof Response === "function";
+const isReadableStreamSupported = isFetchSupported && typeof ReadableStream === "function";
+const encodeText = isFetchSupported && (typeof TextEncoder === "function" ? /* @__PURE__ */ ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) : async (str) => new Uint8Array(await new Response(str).arrayBuffer()));
+const test = (fn, ...args) => {
+  try {
+    return !!fn(...args);
+  } catch (e) {
+    return false;
+  }
+};
+const supportsRequestStream = isReadableStreamSupported && test(() => {
+  let duplexAccessed = false;
+  const hasContentType = new Request(index.default.origin, {
+    body: new ReadableStream(),
+    method: "POST",
+    get duplex() {
+      duplexAccessed = true;
+      return "half";
+    }
+  }).headers.has("Content-Type");
+  return duplexAccessed && !hasContentType;
+});
+const DEFAULT_CHUNK_SIZE = 64 * 1024;
+const supportsResponseStream = isReadableStreamSupported && test(() => utils.default.isReadableStream(new Response("").body));
+const resolvers = {
+  stream: supportsResponseStream && ((res) => res.body)
+};
+isFetchSupported && ((res) => {
+  ["text", "arrayBuffer", "blob", "formData", "stream"].forEach((type) => {
+    !resolvers[type] && (resolvers[type] = utils.default.isFunction(res[type]) ? (res2) => res2[type]() : (_, config) => {
+      throw new AxiosError.default(`Response type '${type}' is not supported`, AxiosError.default.ERR_NOT_SUPPORT, config);
+    });
+  });
+})(new Response());
+const getBodyLength = async (body) => {
+  if (body == null) {
+    return 0;
+  }
+  if (utils.default.isBlob(body)) {
+    return body.size;
+  }
+  if (utils.default.isSpecCompliantForm(body)) {
+    const _request = new Request(index.default.origin, {
+      method: "POST",
+      body
+    });
+    return (await _request.arrayBuffer()).byteLength;
+  }
+  if (utils.default.isArrayBufferView(body) || utils.default.isArrayBuffer(body)) {
+    return body.byteLength;
+  }
+  if (utils.default.isURLSearchParams(body)) {
+    body = body + "";
+  }
+  if (utils.default.isString(body)) {
+    return (await encodeText(body)).byteLength;
+  }
+};
+const resolveBodyLength = async (headers, body) => {
+  const length = utils.default.toFiniteNumber(headers.getContentLength());
+  return length == null ? getBodyLength(body) : length;
+};
+const fetchAdapter = isFetchSupported && (async (config) => {
+  let {
+    url,
+    method,
+    data,
+    signal,
+    cancelToken,
+    timeout,
+    onDownloadProgress,
+    onUploadProgress,
+    responseType,
+    headers,
+    withCredentials = "same-origin",
+    fetchOptions
+  } = resolveConfig.default(config);
+  responseType = responseType ? (responseType + "").toLowerCase() : "text";
+  let composedSignal = composeSignals.default([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
+  let request;
+  const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
+    composedSignal.unsubscribe();
+  });
+  let requestContentLength;
+  try {
+    if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) {
+      let _request = new Request(url, {
+        method: "POST",
+        body: data,
+        duplex: "half"
+      });
+      let contentTypeHeader;
+      if (utils.default.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) {
+        headers.setContentType(contentTypeHeader);
+      }
+      if (_request.body) {
+        const [onProgress, flush] = progressEventReducer.progressEventDecorator(
+          requestContentLength,
+          progressEventReducer.progressEventReducer(progressEventReducer.asyncDecorator(onUploadProgress))
+        );
+        data = trackStream.trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+      }
+    }
+    if (!utils.default.isString(withCredentials)) {
+      withCredentials = withCredentials ? "include" : "omit";
+    }
+    const isCredentialsSupported = "credentials" in Request.prototype;
+    request = new Request(url, {
+      ...fetchOptions,
+      signal: composedSignal,
+      method: method.toUpperCase(),
+      headers: headers.normalize().toJSON(),
+      body: data,
+      duplex: "half",
+      credentials: isCredentialsSupported ? withCredentials : void 0
+    });
+    let response = await fetch(request);
+    const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
+    if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) {
+      const options = {};
+      ["status", "statusText", "headers"].forEach((prop) => {
+        options[prop] = response[prop];
+      });
+      const responseContentLength = utils.default.toFiniteNumber(response.headers.get("content-length"));
+      const [onProgress, flush] = onDownloadProgress && progressEventReducer.progressEventDecorator(
+        responseContentLength,
+        progressEventReducer.progressEventReducer(progressEventReducer.asyncDecorator(onDownloadProgress), true)
+      ) || [];
+      response = new Response(
+        trackStream.trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+          flush && flush();
+          unsubscribe && unsubscribe();
+        }),
+        options
+      );
+    }
+    responseType = responseType || "text";
+    let responseData = await resolvers[utils.default.findKey(resolvers, responseType) || "text"](response, config);
+    !isStreamResponse && unsubscribe && unsubscribe();
+    return await new Promise((resolve, reject) => {
+      settle.default(resolve, reject, {
+        data: responseData,
+        headers: AxiosHeaders.default.from(response.headers),
+        status: response.status,
+        statusText: response.statusText,
+        config,
+        request
+      });
+    });
+  } catch (err) {
+    unsubscribe && unsubscribe();
+    if (err && err.name === "TypeError" && /fetch/i.test(err.message)) {
+      throw Object.assign(
+        new AxiosError.default("Network Error", AxiosError.default.ERR_NETWORK, config, request),
+        {
+          cause: err.cause || err
+        }
+      );
+    }
+    throw AxiosError.default.from(err, err && err.code, config, request);
+  }
+});
+exports.default = fetchAdapter;

package/lib/node_modules/.pnpm/axios@1.8.4/node_modules/axios/lib/adapters/xhr.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const utils = require("../utils.js");
+const settle = require("../core/settle.js");
+const transitional = require("../defaults/transitional.js");
+const AxiosError = require("../core/AxiosError.js");
+const CanceledError = require("../cancel/CanceledError.js");
+const parseProtocol = require("../helpers/parseProtocol.js");
+const index = require("../platform/index.js");
+const AxiosHeaders = require("../core/AxiosHeaders.js");
+const progressEventReducer = require("../helpers/progressEventReducer.js");
+const resolveConfig = require("../helpers/resolveConfig.js");
+const isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
+const xhrAdapter = isXHRAdapterSupported && function(config) {
+  return new Promise(function dispatchXhrRequest(resolve, reject) {
+    const _config = resolveConfig.default(config);
+    let requestData = _config.data;
+    const requestHeaders = AxiosHeaders.default.from(_config.headers).normalize();
+    let { responseType, onUploadProgress, onDownloadProgress } = _config;
+    let onCanceled;
+    let uploadThrottled, downloadThrottled;
+    let flushUpload, flushDownload;
+    function done() {
+      flushUpload && flushUpload();
+      flushDownload && flushDownload();
+      _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
+      _config.signal && _config.signal.removeEventListener("abort", onCanceled);
+    }
+    let request = new XMLHttpRequest();
+    request.open(_config.method.toUpperCase(), _config.url, true);
+    request.timeout = _config.timeout;
+    function onloadend() {
+      if (!request) {
+        return;
+      }
+      const responseHeaders = AxiosHeaders.default.from(
+        "getAllResponseHeaders" in request && request.getAllResponseHeaders()
+      );
+      const responseData = !responseType || responseType === "text" || responseType === "json" ? request.responseText : request.response;
+      const response = {
+        data: responseData,
+        status: request.status,
+        statusText: request.statusText,
+        headers: responseHeaders,
+        config,
+        request
+      };
+      settle.default(function _resolve(value) {
+        resolve(value);
+        done();
+      }, function _reject(err) {
+        reject(err);
+        done();
+      }, response);
+      request = null;
+    }
+    if ("onloadend" in request) {
+      request.onloadend = onloadend;
+    } else {
+      request.onreadystatechange = function handleLoad() {
+        if (!request || request.readyState !== 4) {
+          return;
+        }
+        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) {
+          return;
+        }
+        setTimeout(onloadend);
+      };
+    }
+    request.onabort = function handleAbort() {
+      if (!request) {
+        return;
+      }
+      reject(new AxiosError.default("Request aborted", AxiosError.default.ECONNABORTED, config, request));
+      request = null;
+    };
+    request.onerror = function handleError() {
+      reject(new AxiosError.default("Network Error", AxiosError.default.ERR_NETWORK, config, request));
+      request = null;
+    };
+    request.ontimeout = function handleTimeout() {
+      let timeoutErrorMessage = _config.timeout ? "timeout of " + _config.timeout + "ms exceeded" : "timeout exceeded";
+      const transitional$1 = _config.transitional || transitional.default;
+      if (_config.timeoutErrorMessage) {
+        timeoutErrorMessage = _config.timeoutErrorMessage;
+      }
+      reject(new AxiosError.default(
+        timeoutErrorMessage,
+        transitional$1.clarifyTimeoutError ? AxiosError.default.ETIMEDOUT : AxiosError.default.ECONNABORTED,
+        config,
+        request
+      ));
+      request = null;
+    };
+    requestData === void 0 && requestHeaders.setContentType(null);
+    if ("setRequestHeader" in request) {
+      utils.default.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
+        request.setRequestHeader(key, val);
+      });
+    }
+    if (!utils.default.isUndefined(_config.withCredentials)) {
+      request.withCredentials = !!_config.withCredentials;
+    }
+    if (responseType && responseType !== "json") {
+      request.responseType = _config.responseType;
+    }
+    if (onDownloadProgress) {
+      [downloadThrottled, flushDownload] = progressEventReducer.progressEventReducer(onDownloadProgress, true);
+      request.addEventListener("progress", downloadThrottled);
+    }
+    if (onUploadProgress && request.upload) {
+      [uploadThrottled, flushUpload] = progressEventReducer.progressEventReducer(onUploadProgress);
+      request.upload.addEventListener("progress", uploadThrottled);
+      request.upload.addEventListener("loadend", flushUpload);
+    }
+    if (_config.cancelToken || _config.signal) {
+      onCanceled = (cancel) => {
+        if (!request) {
+          return;
+        }
+        reject(!cancel || cancel.type ? new CanceledError.default(null, config, request) : cancel);
+        request.abort();
+        request = null;
+      };
+      _config.cancelToken && _config.cancelToken.subscribe(onCanceled);
+      if (_config.signal) {
+        _config.signal.aborted ? onCanceled() : _config.signal.addEventListener("abort", onCanceled);
+      }
+    }
+    const protocol = parseProtocol.default(_config.url);
+    if (protocol && index.default.protocols.indexOf(protocol) === -1) {
+      reject(new AxiosError.default("Unsupported protocol " + protocol + ":", AxiosError.default.ERR_BAD_REQUEST, config));
+      return;
+    }
+    request.send(requestData || null);
+  });
+};
+exports.default = xhrAdapter;

package/lib/node_modules/.pnpm/axios@1.8.4/node_modules/axios/lib/axios.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const utils = require("./utils.js");
+const bind = require("./helpers/bind.js");
+const Axios = require("./core/Axios.js");
+const mergeConfig = require("./core/mergeConfig.js");
+const index = require("./defaults/index.js");
+const formDataToJSON = require("./helpers/formDataToJSON.js");
+const CanceledError = require("./cancel/CanceledError.js");
+const CancelToken = require("./cancel/CancelToken.js");
+const isCancel = require("./cancel/isCancel.js");
+const data = require("./env/data.js");
+const toFormData = require("./helpers/toFormData.js");
+const AxiosError = require("./core/AxiosError.js");
+const spread = require("./helpers/spread.js");
+const isAxiosError = require("./helpers/isAxiosError.js");
+const AxiosHeaders = require("./core/AxiosHeaders.js");
+const adapters = require("./adapters/adapters.js");
+const HttpStatusCode = require("./helpers/HttpStatusCode.js");
+function createInstance(defaultConfig) {
+  const context = new Axios.default(defaultConfig);
+  const instance = bind.default(Axios.default.prototype.request, context);
+  utils.default.extend(instance, Axios.default.prototype, context, { allOwnKeys: true });
+  utils.default.extend(instance, context, null, { allOwnKeys: true });
+  instance.create = function create(instanceConfig) {
+    return createInstance(mergeConfig.default(defaultConfig, instanceConfig));
+  };
+  return instance;
+}
+const axios = createInstance(index.default);
+axios.Axios = Axios.default;
+axios.CanceledError = CanceledError.default;
+axios.CancelToken = CancelToken.default;
+axios.isCancel = isCancel.default;
+axios.VERSION = data.VERSION;
+axios.toFormData = toFormData.default;
+axios.AxiosError = AxiosError.default;
+axios.Cancel = axios.CanceledError;
+axios.all = function all(promises) {
+  return Promise.all(promises);
+};
+axios.spread = spread.default;
+axios.isAxiosError = isAxiosError.default;
+axios.mergeConfig = mergeConfig.default;
+axios.AxiosHeaders = AxiosHeaders.default;
+axios.formToJSON = (thing) => formDataToJSON.default(utils.default.isHTMLForm(thing) ? new FormData(thing) : thing);
+axios.getAdapter = adapters.default.getAdapter;
+axios.HttpStatusCode = HttpStatusCode.default;
+axios.default = axios;
+exports.default = axios;

package/lib/node_modules/.pnpm/axios@1.8.4/node_modules/axios/lib/cancel/CancelToken.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const CanceledError = require("./CanceledError.js");
+class CancelToken {
+  constructor(executor) {
+    if (typeof executor !== "function") {
+      throw new TypeError("executor must be a function.");
+    }
+    let resolvePromise;
+    this.promise = new Promise(function promiseExecutor(resolve) {
+      resolvePromise = resolve;
+    });
+    const token = this;
+    this.promise.then((cancel) => {
+      if (!token._listeners) return;
+      let i = token._listeners.length;
+      while (i-- > 0) {
+        token._listeners[i](cancel);
+      }
+      token._listeners = null;
+    });
+    this.promise.then = (onfulfilled) => {
+      let _resolve;
+      const promise = new Promise((resolve) => {
+        token.subscribe(resolve);
+        _resolve = resolve;
+      }).then(onfulfilled);
+      promise.cancel = function reject() {
+        token.unsubscribe(_resolve);
+      };
+      return promise;
+    };
+    executor(function cancel(message, config, request) {
+      if (token.reason) {
+        return;
+      }
+      token.reason = new CanceledError.default(message, config, request);
+      resolvePromise(token.reason);
+    });
+  }
+  /**
+   * Throws a `CanceledError` if cancellation has been requested.
+   */
+  throwIfRequested() {
+    if (this.reason) {
+      throw this.reason;
+    }
+  }
+  /**
+   * Subscribe to the cancel signal
+   */
+  subscribe(listener) {
+    if (this.reason) {
+      listener(this.reason);
+      return;
+    }
+    if (this._listeners) {
+      this._listeners.push(listener);
+    } else {
+      this._listeners = [listener];
+    }
+  }
+  /**
+   * Unsubscribe from the cancel signal
+   */
+  unsubscribe(listener) {
+    if (!this._listeners) {
+      return;
+    }
+    const index = this._listeners.indexOf(listener);
+    if (index !== -1) {
+      this._listeners.splice(index, 1);
+    }
+  }
+  toAbortSignal() {
+    const controller = new AbortController();
+    const abort = (err) => {
+      controller.abort(err);
+    };
+    this.subscribe(abort);
+    controller.signal.unsubscribe = () => this.unsubscribe(abort);
+    return controller.signal;
+  }
+  /**
+   * Returns an object that contains a new `CancelToken` and a function that, when called,
+   * cancels the `CancelToken`.
+   */
+  static source() {
+    let cancel;
+    const token = new CancelToken(function executor(c) {
+      cancel = c;
+    });
+    return {
+      token,
+      cancel
+    };
+  }
+}
+exports.default = CancelToken;

package/lib/node_modules/.pnpm/axios@1.8.4/node_modules/axios/lib/cancel/CanceledError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const AxiosError = require("../core/AxiosError.js");
+const utils = require("../utils.js");
+function CanceledError(message, config, request) {
+  AxiosError.default.call(this, message == null ? "canceled" : message, AxiosError.default.ERR_CANCELED, config, request);
+  this.name = "CanceledError";
+}
+utils.default.inherits(CanceledError, AxiosError.default, {
+  __CANCEL__: true
+});
+exports.default = CanceledError;

package/lib/node_modules/.pnpm/axios@1.8.4/node_modules/axios/lib/cancel/isCancel.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+function isCancel(value) {
+  return !!(value && value.__CANCEL__);
+}
+exports.default = isCancel;