@snail-js/api 0.1.1 → 0.1.3

package/dist/{snail-api.umd.js → snail-api.umd.cjs}

@@ -5,284 +5,1084 @@
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-  const apiKey = (apiInstance) => {
-    const { version, method, url, params, headers } = apiInstance;
-    return `[${method}]${version ? `-v${version}` : ""}-${url}${params ? `-${recordToString(params)}` : ""}${headers ? `-${recordToString(headers)}` : ""}`;
-  };
-  function recordToString(record) {
-    return Object.keys(record).map((key) => {
-      return `${key}=${record[key]}`;
-    }).sort((a, b) => a.localeCompare(b)).join("&");
-  }
-  function getResponseDataFromCache(cacheKey) {
-    return cacheKey;
-  }
-  function deepCopy(obj) {
-    if (typeof obj !== "object" || obj === null) {
-      return obj;
-    }
-    if (Array.isArray(obj)) {
-      return obj.map((item) => deepCopy(item));
-    }
-    const copy = {};
-    for (const key in obj) {
-      if (Object.prototype.hasOwnProperty.call(obj, key)) {
-        copy[key] = deepCopy(obj[key]);
+  var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+  /*! *****************************************************************************
+  	Copyright (C) Microsoft. All rights reserved.
+  	Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+  	this file except in compliance with the License. You may obtain a copy of the
+  	License at http://www.apache.org/licenses/LICENSE-2.0
+  
+  	THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  	KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+  	WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+  	MERCHANTABLITY OR NON-INFRINGEMENT.
+  
+  	See the Apache Version 2.0 License for specific language governing permissions
+  	and limitations under the License.
+  	***************************************************************************** */
+  var Reflect$1;
+  (function(Reflect2) {
+    (function(factory) {
+      var root = typeof globalThis === "object" ? globalThis : typeof commonjsGlobal === "object" ? commonjsGlobal : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
+      var exporter = makeExporter(Reflect2);
+      if (typeof root.Reflect !== "undefined") {
+        exporter = makeExporter(root.Reflect, exporter);
+      }
+      factory(exporter, root);
+      if (typeof root.Reflect === "undefined") {
+        root.Reflect = Reflect2;
+      }
+      function makeExporter(target, previous) {
+        return function(key, value) {
+          Object.defineProperty(target, key, { configurable: true, writable: true, value });
+          if (previous)
+            previous(key, value);
+        };
       }
-    }
-    return copy;
-  }
-  var RequestMethod = /* @__PURE__ */ ((RequestMethod2) => {
-    RequestMethod2["GET"] = "GET";
-    RequestMethod2["HEAD"] = "HEAD";
-    RequestMethod2["POST"] = "POST";
-    RequestMethod2["PUT"] = "PUT";
-    RequestMethod2["DELETE"] = "DELETE";
-    RequestMethod2["PATCH"] = "PATCH";
-    RequestMethod2["OPTIONS"] = "OPTIONS";
-    return RequestMethod2;
-  })(RequestMethod || {});
-  var VersioningType = /* @__PURE__ */ ((VersioningType2) => {
-    VersioningType2[VersioningType2["Uri"] = 0] = "Uri";
-    VersioningType2[VersioningType2["Header"] = 1] = "Header";
-    VersioningType2[VersioningType2["Query"] = 2] = "Query";
-    VersioningType2[VersioningType2["Custom"] = 3] = "Custom";
-    return VersioningType2;
-  })(VersioningType || {});
-  var CacheType = /* @__PURE__ */ ((CacheType2) => {
-    CacheType2[CacheType2["Memory"] = 0] = "Memory";
-    CacheType2[CacheType2["IndexDB"] = 1] = "IndexDB";
-    CacheType2[CacheType2["LocalStorage"] = 2] = "LocalStorage";
-    return CacheType2;
-  })(CacheType || {});
-  const versionHandlers = {
-    [VersioningType.Uri]: (version, versioning) => {
-      const prefix = versioning.prefix || "v";
-      return {
-        url: `${prefix}${version}`
-      };
-    },
-    [VersioningType.Header]: (version, versioning) => {
-      const headers = {
-        [versioning.header]: version
-      };
-      return {
-        headers
-      };
-    },
-    [VersioningType.Query]: (version, versioning) => {
-      const key = versioning.key || "version";
-      const separator = "?";
-      return {
-        url: `${separator}${key}=${version}`
+      function functionThis() {
+        try {
+          return Function("return this;")();
+        } catch (_) {
+        }
+      }
+      function indirectEvalThis() {
+        try {
+          return (void 0, eval)("(function() { return this; })()");
+        } catch (_) {
+        }
+      }
+      function sloppyModeThis() {
+        return functionThis() || indirectEvalThis();
+      }
+    })(function(exporter, root) {
+      var hasOwn = Object.prototype.hasOwnProperty;
+      var supportsSymbol = typeof Symbol === "function";
+      var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+      var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+      var supportsCreate = typeof Object.create === "function";
+      var supportsProto = { __proto__: [] } instanceof Array;
+      var downLevel = !supportsCreate && !supportsProto;
+      var HashMap = {
+        // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+        create: supportsCreate ? function() {
+          return MakeDictionary(/* @__PURE__ */ Object.create(null));
+        } : supportsProto ? function() {
+          return MakeDictionary({ __proto__: null });
+        } : function() {
+          return MakeDictionary({});
+        },
+        has: downLevel ? function(map, key) {
+          return hasOwn.call(map, key);
+        } : function(map, key) {
+          return key in map;
+        },
+        get: downLevel ? function(map, key) {
+          return hasOwn.call(map, key) ? map[key] : void 0;
+        } : function(map, key) {
+          return map[key];
+        }
       };
-    },
-    [VersioningType.Custom]: (version, versioning) => {
-      return versioning.extractor({
-        version
-      });
-    }
-  };
-  function applyVersioning(version, versioning) {
-    const handler = versionHandlers[versioning.type];
-    return handler(
-      version,
-      versioning
-    );
-  }
-  class Api {
-    constructor(method, url, context, config) {
-      __publicField(this, "baseURL");
-      __publicField(this, "url");
-      __publicField(this, "data");
-      __publicField(this, "params");
-      __publicField(this, "headers");
-      __publicField(this, "key");
-      // public config: ApiConfig<R> | undefined;
-      __publicField(this, "method");
-      __publicField(this, "hitCache");
-      __publicField(this, "context");
-      __publicField(this, "version");
-      __publicField(this, "versioning");
-      __publicField(this, "name");
-      __publicField(this, "hitSource");
-      __publicField(this, "timeout");
-      __publicField(this, "transform");
-      __publicField(this, "pipes", []);
-      var _a;
-      const instance = this;
-      instance.name = config == null ? void 0 : config.name;
-      instance.name && this.context.cacheSource.push(this);
-      instance.hitSource = config == null ? void 0 : config.hitSource;
-      instance.method = method;
-      instance.url = url;
-      instance.params = config == null ? void 0 : config.params;
-      instance.headers = config == null ? void 0 : config.headers;
-      instance.transform = config == null ? void 0 : config.transform;
-      instance.context = context;
-      instance.version = (config == null ? void 0 : config.version) || ((_a = instance.context.versioning) == null ? void 0 : _a.defaultVersion);
-      this.timeout = (config == null ? void 0 : config.timeout) || this.context.options.timeout || 5e3;
-      this.handleVersioning();
-      this.key = apiKey(this);
-    }
-    handleVersioning(version) {
-      if (!this.context) return;
-      const { versioning } = this.context;
-      if (versioning) {
-        const { url, headers } = applyVersioning(
-          version || this.version,
-          versioning
+      var functionPrototype = Object.getPrototypeOf(Function);
+      var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
+      var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
+      var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
+      var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : void 0;
+      var metadataRegistry = GetOrCreateMetadataRegistry();
+      var metadataProvider = CreateMetadataProvider(metadataRegistry);
+      function decorate(decorators, target, propertyKey, attributes) {
+        if (!IsUndefined(propertyKey)) {
+          if (!IsArray(decorators))
+            throw new TypeError();
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
+            throw new TypeError();
+          if (IsNull(attributes))
+            attributes = void 0;
+          propertyKey = ToPropertyKey(propertyKey);
+          return DecorateProperty(decorators, target, propertyKey, attributes);
+        } else {
+          if (!IsArray(decorators))
+            throw new TypeError();
+          if (!IsConstructor(target))
+            throw new TypeError();
+          return DecorateConstructor(decorators, target);
+        }
+      }
+      exporter("decorate", decorate);
+      function metadata(metadataKey, metadataValue) {
+        function decorator(target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError();
+          if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
+            throw new TypeError();
+          OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+        }
+        return decorator;
+      }
+      exporter("metadata", metadata);
+      function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+      }
+      exporter("defineMetadata", defineMetadata);
+      function hasMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryHasMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("hasMetadata", hasMetadata);
+      function hasOwnMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("hasOwnMetadata", hasOwnMetadata);
+      function getMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryGetMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("getMetadata", getMetadata);
+      function getOwnMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("getOwnMetadata", getOwnMetadata);
+      function getMetadataKeys(target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryMetadataKeys(target, propertyKey);
+      }
+      exporter("getMetadataKeys", getMetadataKeys);
+      function getOwnMetadataKeys(target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryOwnMetadataKeys(target, propertyKey);
+      }
+      exporter("getOwnMetadataKeys", getOwnMetadataKeys);
+      function deleteMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        if (!IsObject(target))
+          throw new TypeError();
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        var provider = GetMetadataProvider(
+          target,
+          propertyKey,
+          /*Create*/
+          false
         );
-        this.versioning = {
-          url,
-          headers
+        if (IsUndefined(provider))
+          return false;
+        return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("deleteMetadata", deleteMetadata);
+      function DecorateConstructor(decorators, target) {
+        for (var i = decorators.length - 1; i >= 0; --i) {
+          var decorator = decorators[i];
+          var decorated = decorator(target);
+          if (!IsUndefined(decorated) && !IsNull(decorated)) {
+            if (!IsConstructor(decorated))
+              throw new TypeError();
+            target = decorated;
+          }
+        }
+        return target;
+      }
+      function DecorateProperty(decorators, target, propertyKey, descriptor) {
+        for (var i = decorators.length - 1; i >= 0; --i) {
+          var decorator = decorators[i];
+          var decorated = decorator(target, propertyKey, descriptor);
+          if (!IsUndefined(decorated) && !IsNull(decorated)) {
+            if (!IsObject(decorated))
+              throw new TypeError();
+            descriptor = decorated;
+          }
+        }
+        return descriptor;
+      }
+      function OrdinaryHasMetadata(MetadataKey, O, P) {
+        var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+        if (hasOwn2)
+          return true;
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (!IsNull(parent))
+          return OrdinaryHasMetadata(MetadataKey, parent, P);
+        return false;
+      }
+      function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
+        var provider = GetMetadataProvider(
+          O,
+          P,
+          /*Create*/
+          false
+        );
+        if (IsUndefined(provider))
+          return false;
+        return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
+      }
+      function OrdinaryGetMetadata(MetadataKey, O, P) {
+        var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+        if (hasOwn2)
+          return OrdinaryGetOwnMetadata(MetadataKey, O, P);
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (!IsNull(parent))
+          return OrdinaryGetMetadata(MetadataKey, parent, P);
+        return void 0;
+      }
+      function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
+        var provider = GetMetadataProvider(
+          O,
+          P,
+          /*Create*/
+          false
+        );
+        if (IsUndefined(provider))
+          return;
+        return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
+      }
+      function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
+        var provider = GetMetadataProvider(
+          O,
+          P,
+          /*Create*/
+          true
+        );
+        provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
+      }
+      function OrdinaryMetadataKeys(O, P) {
+        var ownKeys = OrdinaryOwnMetadataKeys(O, P);
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (parent === null)
+          return ownKeys;
+        var parentKeys = OrdinaryMetadataKeys(parent, P);
+        if (parentKeys.length <= 0)
+          return ownKeys;
+        if (ownKeys.length <= 0)
+          return parentKeys;
+        var set = new _Set();
+        var keys = [];
+        for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {
+          var key = ownKeys_1[_i];
+          var hasKey = set.has(key);
+          if (!hasKey) {
+            set.add(key);
+            keys.push(key);
+          }
+        }
+        for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
+          var key = parentKeys_1[_a];
+          var hasKey = set.has(key);
+          if (!hasKey) {
+            set.add(key);
+            keys.push(key);
+          }
+        }
+        return keys;
+      }
+      function OrdinaryOwnMetadataKeys(O, P) {
+        var provider = GetMetadataProvider(
+          O,
+          P,
+          /*create*/
+          false
+        );
+        if (!provider) {
+          return [];
+        }
+        return provider.OrdinaryOwnMetadataKeys(O, P);
+      }
+      function Type(x) {
+        if (x === null)
+          return 1;
+        switch (typeof x) {
+          case "undefined":
+            return 0;
+          case "boolean":
+            return 2;
+          case "string":
+            return 3;
+          case "symbol":
+            return 4;
+          case "number":
+            return 5;
+          case "object":
+            return x === null ? 1 : 6;
+          default:
+            return 6;
+        }
+      }
+      function IsUndefined(x) {
+        return x === void 0;
+      }
+      function IsNull(x) {
+        return x === null;
+      }
+      function IsSymbol(x) {
+        return typeof x === "symbol";
+      }
+      function IsObject(x) {
+        return typeof x === "object" ? x !== null : typeof x === "function";
+      }
+      function ToPrimitive(input, PreferredType) {
+        switch (Type(input)) {
+          case 0:
+            return input;
+          case 1:
+            return input;
+          case 2:
+            return input;
+          case 3:
+            return input;
+          case 4:
+            return input;
+          case 5:
+            return input;
+        }
+        var hint = "string";
+        var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
+        if (exoticToPrim !== void 0) {
+          var result = exoticToPrim.call(input, hint);
+          if (IsObject(result))
+            throw new TypeError();
+          return result;
+        }
+        return OrdinaryToPrimitive(input);
+      }
+      function OrdinaryToPrimitive(O, hint) {
+        var valueOf, result;
+        {
+          var toString_1 = O.toString;
+          if (IsCallable(toString_1)) {
+            var result = toString_1.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+          var valueOf = O.valueOf;
+          if (IsCallable(valueOf)) {
+            var result = valueOf.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+        }
+        throw new TypeError();
+      }
+      function ToBoolean(argument) {
+        return !!argument;
+      }
+      function ToString(argument) {
+        return "" + argument;
+      }
+      function ToPropertyKey(argument) {
+        var key = ToPrimitive(argument);
+        if (IsSymbol(key))
+          return key;
+        return ToString(key);
+      }
+      function IsArray(argument) {
+        return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
+      }
+      function IsCallable(argument) {
+        return typeof argument === "function";
+      }
+      function IsConstructor(argument) {
+        return typeof argument === "function";
+      }
+      function IsPropertyKey(argument) {
+        switch (Type(argument)) {
+          case 3:
+            return true;
+          case 4:
+            return true;
+          default:
+            return false;
+        }
+      }
+      function SameValueZero(x, y) {
+        return x === y || x !== x && y !== y;
+      }
+      function GetMethod(V, P) {
+        var func = V[P];
+        if (func === void 0 || func === null)
+          return void 0;
+        if (!IsCallable(func))
+          throw new TypeError();
+        return func;
+      }
+      function GetIterator(obj) {
+        var method = GetMethod(obj, iteratorSymbol);
+        if (!IsCallable(method))
+          throw new TypeError();
+        var iterator = method.call(obj);
+        if (!IsObject(iterator))
+          throw new TypeError();
+        return iterator;
+      }
+      function IteratorValue(iterResult) {
+        return iterResult.value;
+      }
+      function IteratorStep(iterator) {
+        var result = iterator.next();
+        return result.done ? false : result;
+      }
+      function IteratorClose(iterator) {
+        var f = iterator["return"];
+        if (f)
+          f.call(iterator);
+      }
+      function OrdinaryGetPrototypeOf(O) {
+        var proto = Object.getPrototypeOf(O);
+        if (typeof O !== "function" || O === functionPrototype)
+          return proto;
+        if (proto !== functionPrototype)
+          return proto;
+        var prototype2 = O.prototype;
+        var prototypeProto = prototype2 && Object.getPrototypeOf(prototype2);
+        if (prototypeProto == null || prototypeProto === Object.prototype)
+          return proto;
+        var constructor = prototypeProto.constructor;
+        if (typeof constructor !== "function")
+          return proto;
+        if (constructor === O)
+          return proto;
+        return constructor;
+      }
+      function CreateMetadataRegistry() {
+        var fallback;
+        if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
+          fallback = CreateFallbackProvider(root.Reflect);
+        }
+        var first;
+        var second;
+        var rest;
+        var targetProviderMap = new _WeakMap();
+        var registry = {
+          registerProvider,
+          getProvider,
+          setProvider
         };
+        return registry;
+        function registerProvider(provider) {
+          if (!Object.isExtensible(registry)) {
+            throw new Error("Cannot add provider to a frozen registry.");
+          }
+          switch (true) {
+            case fallback === provider:
+              break;
+            case IsUndefined(first):
+              first = provider;
+              break;
+            case first === provider:
+              break;
+            case IsUndefined(second):
+              second = provider;
+              break;
+            case second === provider:
+              break;
+            default:
+              if (rest === void 0)
+                rest = new _Set();
+              rest.add(provider);
+              break;
+          }
+        }
+        function getProviderNoCache(O, P) {
+          if (!IsUndefined(first)) {
+            if (first.isProviderFor(O, P))
+              return first;
+            if (!IsUndefined(second)) {
+              if (second.isProviderFor(O, P))
+                return first;
+              if (!IsUndefined(rest)) {
+                var iterator = GetIterator(rest);
+                while (true) {
+                  var next = IteratorStep(iterator);
+                  if (!next) {
+                    return void 0;
+                  }
+                  var provider = IteratorValue(next);
+                  if (provider.isProviderFor(O, P)) {
+                    IteratorClose(iterator);
+                    return provider;
+                  }
+                }
+              }
+            }
+          }
+          if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
+            return fallback;
+          }
+          return void 0;
+        }
+        function getProvider(O, P) {
+          var providerMap = targetProviderMap.get(O);
+          var provider;
+          if (!IsUndefined(providerMap)) {
+            provider = providerMap.get(P);
+          }
+          if (!IsUndefined(provider)) {
+            return provider;
+          }
+          provider = getProviderNoCache(O, P);
+          if (!IsUndefined(provider)) {
+            if (IsUndefined(providerMap)) {
+              providerMap = new _Map();
+              targetProviderMap.set(O, providerMap);
+            }
+            providerMap.set(P, provider);
+          }
+          return provider;
+        }
+        function hasProvider(provider) {
+          if (IsUndefined(provider))
+            throw new TypeError();
+          return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
+        }
+        function setProvider(O, P, provider) {
+          if (!hasProvider(provider)) {
+            throw new Error("Metadata provider not registered.");
+          }
+          var existingProvider = getProvider(O, P);
+          if (existingProvider !== provider) {
+            if (!IsUndefined(existingProvider)) {
+              return false;
+            }
+            var providerMap = targetProviderMap.get(O);
+            if (IsUndefined(providerMap)) {
+              providerMap = new _Map();
+              targetProviderMap.set(O, providerMap);
+            }
+            providerMap.set(P, provider);
+          }
+          return true;
+        }
       }
-      return;
-    }
-    /**
-     *
-     * @param options 发送配置：子项params,data
-     * 泛型<R = any, E = any>R返回数据类型, E返回错误类型(code!=0)
-     * @returns
-     */
-    send(options) {
-      this.data = options == null ? void 0 : options.data;
-      this.params = options == null ? void 0 : options.params;
-      if ((options == null ? void 0 : options.params) || (options == null ? void 0 : options.data)) {
-        this.key = apiKey(this);
-      }
-      const version = (options == null ? void 0 : options.version) || this.version;
-      console.log("send version:", version);
-      this.handleVersioning(version);
-      return new Promise(async (resolve, reject) => {
-        var _a, _b, _c;
-        const { data, headers } = this.processRequestPipes();
-        this.data = data;
-        this.headers = headers;
-        this.key = apiKey(this);
-        const cachedResponse = await this.checkCache(version);
-        if (cachedResponse) {
-          const versionUrl = ((_a = this.versioning) == null ? void 0 : _a.url) ? (_b = this.versioning) == null ? void 0 : _b.url : "";
-          console.warn(
-            `请求[${this.context.baseURL}/${versionUrl == "" ? "" : `${versionUrl}/`}${this.url}]命中缓存`
-          );
-          return resolve({
-            error: null,
-            data: cachedResponse,
-            hitCache: this.hitCache,
-            Catch: (handler) => handler()
+      function GetOrCreateMetadataRegistry() {
+        var metadataRegistry2;
+        if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+          metadataRegistry2 = root.Reflect[registrySymbol];
+        }
+        if (IsUndefined(metadataRegistry2)) {
+          metadataRegistry2 = CreateMetadataRegistry();
+        }
+        if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+          Object.defineProperty(root.Reflect, registrySymbol, {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: metadataRegistry2
           });
         }
-        try {
-          const response = await this.sendRequest();
-          const { code, data: data2, message } = response.data;
-          if (code !== 0) {
-            reject({
-              error: new Error(message, { cause: { code, data: data2 } }),
-              data: null,
-              hitCache: false,
-              Catch: (handler) => handler()
-            });
+        return metadataRegistry2;
+      }
+      function CreateMetadataProvider(registry) {
+        var metadata2 = new _WeakMap();
+        var provider = {
+          isProviderFor: function(O, P) {
+            var targetMetadata = metadata2.get(O);
+            if (IsUndefined(targetMetadata))
+              return false;
+            return targetMetadata.has(P);
+          },
+          OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
+          OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
+          OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
+          OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
+          OrdinaryDeleteMetadata
+        };
+        metadataRegistry.registerProvider(provider);
+        return provider;
+        function GetOrCreateMetadataMap(O, P, Create) {
+          var targetMetadata = metadata2.get(O);
+          var createdTargetMetadata = false;
+          if (IsUndefined(targetMetadata)) {
+            if (!Create)
+              return void 0;
+            targetMetadata = new _Map();
+            metadata2.set(O, targetMetadata);
+            createdTargetMetadata = true;
           }
-          const transformedData = this.transform ? this.transform(data2) : data2;
-          (_c = this.context.cacheStorage) == null ? void 0 : _c.set(this.key, transformedData);
-          resolve({
-            error: null,
-            data: transformedData,
-            hitCache: false,
-            Catch: (handler) => handler()
-          });
-          this.lapsed(version);
-        } catch (error) {
-          resolve({
-            error,
-            data: null,
-            hitCache: false,
-            Catch: (handler) => handler(error)
-          });
+          var metadataMap = targetMetadata.get(P);
+          if (IsUndefined(metadataMap)) {
+            if (!Create)
+              return void 0;
+            metadataMap = new _Map();
+            targetMetadata.set(P, metadataMap);
+            if (!registry.setProvider(O, P, provider)) {
+              targetMetadata.delete(P);
+              if (createdTargetMetadata) {
+                metadata2.delete(O);
+              }
+              throw new Error("Wrong provider for target.");
+            }
+          }
+          return metadataMap;
         }
-      });
-    }
-    async checkCache(version) {
-      if (!this.context.cacheStorage) return null;
-      return new Promise(async (resolve) => {
-        if (!this.context.cacheStorage) {
-          return resolve(null);
-        }
-        let tempKey;
-        if (version) {
-          tempKey = apiKey({
-            ...this,
-            version
-          });
+        function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(
+            O,
+            P,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(metadataMap))
+            return false;
+          return ToBoolean(metadataMap.has(MetadataKey));
         }
-        const { error, data } = await this.context.cacheStorage.get(
-          tempKey ? tempKey : this.key
-        );
-        if (error) {
-          console.warn(error);
-          return resolve(null);
+        function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(
+            O,
+            P,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(metadataMap))
+            return void 0;
+          return metadataMap.get(MetadataKey);
+        }
+        function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(
+            O,
+            P,
+            /*Create*/
+            true
+          );
+          metadataMap.set(MetadataKey, MetadataValue);
+        }
+        function OrdinaryOwnMetadataKeys2(O, P) {
+          var keys = [];
+          var metadataMap = GetOrCreateMetadataMap(
+            O,
+            P,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(metadataMap))
+            return keys;
+          var keysObj = metadataMap.keys();
+          var iterator = GetIterator(keysObj);
+          var k = 0;
+          while (true) {
+            var next = IteratorStep(iterator);
+            if (!next) {
+              keys.length = k;
+              return keys;
+            }
+            var nextValue = IteratorValue(next);
+            try {
+              keys[k] = nextValue;
+            } catch (e) {
+              try {
+                IteratorClose(iterator);
+              } finally {
+                throw e;
+              }
+            }
+            k++;
+          }
+        }
+        function OrdinaryDeleteMetadata(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(
+            O,
+            P,
+            /*Create*/
+            false
+          );
+          if (IsUndefined(metadataMap))
+            return false;
+          if (!metadataMap.delete(MetadataKey))
+            return false;
+          if (metadataMap.size === 0) {
+            var targetMetadata = metadata2.get(O);
+            if (!IsUndefined(targetMetadata)) {
+              targetMetadata.delete(P);
+              if (targetMetadata.size === 0) {
+                metadata2.delete(targetMetadata);
+              }
+            }
+          }
+          return true;
         }
-        this.hitCache = true;
-        return resolve(data);
-      });
-    }
-    async delCache(version) {
-      let tempKey;
-      if (version) {
-        tempKey = apiKey({
-          ...this,
-          version
-        });
       }
-      await this.context.cacheStorage.delete(tempKey ? tempKey : this.key);
-    }
-    use(pipe) {
-      this.pipes.push(pipe);
-    }
-    processRequestPipes() {
-      let requestData = this.data;
-      let requestHeaders = this.headers || {};
-      if (this.pipes.length > 0) {
-        const pipeResult = this.pipes.reduce(
-          (result, pipe) => {
-            return pipe(result.data, result.headers);
+      function CreateFallbackProvider(reflect) {
+        var defineMetadata2 = reflect.defineMetadata, hasOwnMetadata2 = reflect.hasOwnMetadata, getOwnMetadata2 = reflect.getOwnMetadata, getOwnMetadataKeys2 = reflect.getOwnMetadataKeys, deleteMetadata2 = reflect.deleteMetadata;
+        var metadataOwner = new _WeakMap();
+        var provider = {
+          isProviderFor: function(O, P) {
+            var metadataPropertySet = metadataOwner.get(O);
+            if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
+              return true;
+            }
+            if (getOwnMetadataKeys2(O, P).length) {
+              if (IsUndefined(metadataPropertySet)) {
+                metadataPropertySet = new _Set();
+                metadataOwner.set(O, metadataPropertySet);
+              }
+              metadataPropertySet.add(P);
+              return true;
+            }
+            return false;
           },
-          { data: requestData, headers: requestHeaders }
+          OrdinaryDefineOwnMetadata: defineMetadata2,
+          OrdinaryHasOwnMetadata: hasOwnMetadata2,
+          OrdinaryGetOwnMetadata: getOwnMetadata2,
+          OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
+          OrdinaryDeleteMetadata: deleteMetadata2
+        };
+        return provider;
+      }
+      function GetMetadataProvider(O, P, Create) {
+        var registeredProvider = metadataRegistry.getProvider(O, P);
+        if (!IsUndefined(registeredProvider)) {
+          return registeredProvider;
+        }
+        if (Create) {
+          if (metadataRegistry.setProvider(O, P, metadataProvider)) {
+            return metadataProvider;
+          }
+          throw new Error("Illegal state.");
+        }
+        return void 0;
+      }
+      function CreateMapPolyfill() {
+        var cacheSentinel = {};
+        var arraySentinel = [];
+        var MapIterator = (
+          /** @class */
+          function() {
+            function MapIterator2(keys, values, selector) {
+              this._index = 0;
+              this._keys = keys;
+              this._values = values;
+              this._selector = selector;
+            }
+            MapIterator2.prototype["@@iterator"] = function() {
+              return this;
+            };
+            MapIterator2.prototype[iteratorSymbol] = function() {
+              return this;
+            };
+            MapIterator2.prototype.next = function() {
+              var index = this._index;
+              if (index >= 0 && index < this._keys.length) {
+                var result = this._selector(this._keys[index], this._values[index]);
+                if (index + 1 >= this._keys.length) {
+                  this._index = -1;
+                  this._keys = arraySentinel;
+                  this._values = arraySentinel;
+                } else {
+                  this._index++;
+                }
+                return { value: result, done: false };
+              }
+              return { value: void 0, done: true };
+            };
+            MapIterator2.prototype.throw = function(error) {
+              if (this._index >= 0) {
+                this._index = -1;
+                this._keys = arraySentinel;
+                this._values = arraySentinel;
+              }
+              throw error;
+            };
+            MapIterator2.prototype.return = function(value) {
+              if (this._index >= 0) {
+                this._index = -1;
+                this._keys = arraySentinel;
+                this._values = arraySentinel;
+              }
+              return { value, done: true };
+            };
+            return MapIterator2;
+          }()
+        );
+        var Map2 = (
+          /** @class */
+          function() {
+            function Map3() {
+              this._keys = [];
+              this._values = [];
+              this._cacheKey = cacheSentinel;
+              this._cacheIndex = -2;
+            }
+            Object.defineProperty(Map3.prototype, "size", {
+              get: function() {
+                return this._keys.length;
+              },
+              enumerable: true,
+              configurable: true
+            });
+            Map3.prototype.has = function(key) {
+              return this._find(
+                key,
+                /*insert*/
+                false
+              ) >= 0;
+            };
+            Map3.prototype.get = function(key) {
+              var index = this._find(
+                key,
+                /*insert*/
+                false
+              );
+              return index >= 0 ? this._values[index] : void 0;
+            };
+            Map3.prototype.set = function(key, value) {
+              var index = this._find(
+                key,
+                /*insert*/
+                true
+              );
+              this._values[index] = value;
+              return this;
+            };
+            Map3.prototype.delete = function(key) {
+              var index = this._find(
+                key,
+                /*insert*/
+                false
+              );
+              if (index >= 0) {
+                var size = this._keys.length;
+                for (var i = index + 1; i < size; i++) {
+                  this._keys[i - 1] = this._keys[i];
+                  this._values[i - 1] = this._values[i];
+                }
+                this._keys.length--;
+                this._values.length--;
+                if (SameValueZero(key, this._cacheKey)) {
+                  this._cacheKey = cacheSentinel;
+                  this._cacheIndex = -2;
+                }
+                return true;
+              }
+              return false;
+            };
+            Map3.prototype.clear = function() {
+              this._keys.length = 0;
+              this._values.length = 0;
+              this._cacheKey = cacheSentinel;
+              this._cacheIndex = -2;
+            };
+            Map3.prototype.keys = function() {
+              return new MapIterator(this._keys, this._values, getKey);
+            };
+            Map3.prototype.values = function() {
+              return new MapIterator(this._keys, this._values, getValue);
+            };
+            Map3.prototype.entries = function() {
+              return new MapIterator(this._keys, this._values, getEntry);
+            };
+            Map3.prototype["@@iterator"] = function() {
+              return this.entries();
+            };
+            Map3.prototype[iteratorSymbol] = function() {
+              return this.entries();
+            };
+            Map3.prototype._find = function(key, insert) {
+              if (!SameValueZero(this._cacheKey, key)) {
+                this._cacheIndex = -1;
+                for (var i = 0; i < this._keys.length; i++) {
+                  if (SameValueZero(this._keys[i], key)) {
+                    this._cacheIndex = i;
+                    break;
+                  }
+                }
+              }
+              if (this._cacheIndex < 0 && insert) {
+                this._cacheIndex = this._keys.length;
+                this._keys.push(key);
+                this._values.push(void 0);
+              }
+              return this._cacheIndex;
+            };
+            return Map3;
+          }()
         );
-        requestData = pipeResult.data;
-        requestHeaders = pipeResult.headers;
+        return Map2;
+        function getKey(key, _) {
+          return key;
+        }
+        function getValue(_, value) {
+          return value;
+        }
+        function getEntry(key, value) {
+          return [key, value];
+        }
       }
-      return { data: requestData, headers: requestHeaders };
-    }
-    async sendRequest() {
-      var _a, _b, _c;
-      const headers = {
-        ...this.headers,
-        ...(_a = this.versioning) == null ? void 0 : _a.headers
-      };
-      const versionUrl = ((_b = this.versioning) == null ? void 0 : _b.url) ? (_c = this.versioning) == null ? void 0 : _c.url : "";
-      return await this.context.axiosInstance.request({
-        url: `${versionUrl}/${this.url}`,
-        method: this.method,
-        data: this.data,
-        headers,
-        params: this.params,
-        timeout: this.timeout
-      });
-    }
-    async lapsed(version) {
-      if (!this.hitSource) return;
-      if (typeof this.hitSource === "string") {
-        const { cacheSource } = this.context;
-        const source = cacheSource.find((api) => api.name == this.hitSource);
-        source ?? source.delCache(version);
-      } else {
-        this.hitSource.delCache(version);
+      function CreateSetPolyfill() {
+        var Set2 = (
+          /** @class */
+          function() {
+            function Set3() {
+              this._map = new _Map();
+            }
+            Object.defineProperty(Set3.prototype, "size", {
+              get: function() {
+                return this._map.size;
+              },
+              enumerable: true,
+              configurable: true
+            });
+            Set3.prototype.has = function(value) {
+              return this._map.has(value);
+            };
+            Set3.prototype.add = function(value) {
+              return this._map.set(value, value), this;
+            };
+            Set3.prototype.delete = function(value) {
+              return this._map.delete(value);
+            };
+            Set3.prototype.clear = function() {
+              this._map.clear();
+            };
+            Set3.prototype.keys = function() {
+              return this._map.keys();
+            };
+            Set3.prototype.values = function() {
+              return this._map.keys();
+            };
+            Set3.prototype.entries = function() {
+              return this._map.entries();
+            };
+            Set3.prototype["@@iterator"] = function() {
+              return this.keys();
+            };
+            Set3.prototype[iteratorSymbol] = function() {
+              return this.keys();
+            };
+            return Set3;
+          }()
+        );
+        return Set2;
+      }
+      function CreateWeakMapPolyfill() {
+        var UUID_SIZE = 16;
+        var keys = HashMap.create();
+        var rootKey = CreateUniqueKey();
+        return (
+          /** @class */
+          function() {
+            function WeakMap2() {
+              this._key = CreateUniqueKey();
+            }
+            WeakMap2.prototype.has = function(target) {
+              var table = GetOrCreateWeakMapTable(
+                target,
+                /*create*/
+                false
+              );
+              return table !== void 0 ? HashMap.has(table, this._key) : false;
+            };
+            WeakMap2.prototype.get = function(target) {
+              var table = GetOrCreateWeakMapTable(
+                target,
+                /*create*/
+                false
+              );
+              return table !== void 0 ? HashMap.get(table, this._key) : void 0;
+            };
+            WeakMap2.prototype.set = function(target, value) {
+              var table = GetOrCreateWeakMapTable(
+                target,
+                /*create*/
+                true
+              );
+              table[this._key] = value;
+              return this;
+            };
+            WeakMap2.prototype.delete = function(target) {
+              var table = GetOrCreateWeakMapTable(
+                target,
+                /*create*/
+                false
+              );
+              return table !== void 0 ? delete table[this._key] : false;
+            };
+            WeakMap2.prototype.clear = function() {
+              this._key = CreateUniqueKey();
+            };
+            return WeakMap2;
+          }()
+        );
+        function CreateUniqueKey() {
+          var key;
+          do
+            key = "@@WeakMap@@" + CreateUUID();
+          while (HashMap.has(keys, key));
+          keys[key] = true;
+          return key;
+        }
+        function GetOrCreateWeakMapTable(target, create) {
+          if (!hasOwn.call(target, rootKey)) {
+            if (!create)
+              return void 0;
+            Object.defineProperty(target, rootKey, { value: HashMap.create() });
+          }
+          return target[rootKey];
+        }
+        function FillRandomBytes(buffer, size) {
+          for (var i = 0; i < size; ++i)
+            buffer[i] = Math.random() * 255 | 0;
+          return buffer;
+        }
+        function GenRandomBytes(size) {
+          if (typeof Uint8Array === "function") {
+            var array = new Uint8Array(size);
+            if (typeof crypto !== "undefined") {
+              crypto.getRandomValues(array);
+            } else if (typeof msCrypto !== "undefined") {
+              msCrypto.getRandomValues(array);
+            } else {
+              FillRandomBytes(array, size);
+            }
+            return array;
+          }
+          return FillRandomBytes(new Array(size), size);
+        }
+        function CreateUUID() {
+          var data = GenRandomBytes(UUID_SIZE);
+          data[6] = data[6] & 79 | 64;
+          data[8] = data[8] & 191 | 128;
+          var result = "";
+          for (var offset = 0; offset < UUID_SIZE; ++offset) {
+            var byte = data[offset];
+            if (offset === 4 || offset === 6 || offset === 8)
+              result += "-";
+            if (byte < 16)
+              result += "0";
+            result += byte.toString(16).toLowerCase();
+          }
+          return result;
+        }
       }
-    }
-  }
+      function MakeDictionary(obj) {
+        obj.__ = void 0;
+        delete obj.__;
+        return obj;
+      }
+    });
+  })(Reflect$1 || (Reflect$1 = {}));
   function bind(fn, thisArg) {
     return function wrap() {
       return fn.apply(thisArg, arguments);
@@ -665,7 +1465,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     setImmediate: _setImmediate,
     asap
   };
-  function AxiosError(message, code, config, request, response) {
+  function AxiosError$1(message, code, config, request, response) {
     Error.call(this);
     if (Error.captureStackTrace) {
       Error.captureStackTrace(this, this.constructor);
@@ -682,7 +1482,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       this.status = response.status ? response.status : null;
     }
   }
-  utils$1.inherits(AxiosError, Error, {
+  utils$1.inherits(AxiosError$1, Error, {
     toJSON: function toJSON() {
       return {
         // Standard
@@ -703,7 +1503,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       };
     }
   });
-  const prototype$1 = AxiosError.prototype;
+  const prototype$1 = AxiosError$1.prototype;
   const descriptors = {};
   [
     "ERR_BAD_OPTION_VALUE",
@@ -722,16 +1522,16 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   ].forEach((code) => {
     descriptors[code] = { value: code };
   });
-  Object.defineProperties(AxiosError, descriptors);
+  Object.defineProperties(AxiosError$1, descriptors);
   Object.defineProperty(prototype$1, "isAxiosError", { value: true });
-  AxiosError.from = (error, code, config, request, response, customProps) => {
+  AxiosError$1.from = (error, code, config, request, response, customProps) => {
     const axiosError = Object.create(prototype$1);
     utils$1.toFlatObject(error, axiosError, function filter(obj) {
       return obj !== Error.prototype;
     }, (prop) => {
       return prop !== "isAxiosError";
     });
-    AxiosError.call(axiosError, error.message, code, config, request, response);
+    AxiosError$1.call(axiosError, error.message, code, config, request, response);
     axiosError.cause = error;
     axiosError.name = error.name;
     customProps && Object.assign(axiosError, customProps);
@@ -757,7 +1557,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   const predicates = utils$1.toFlatObject(utils$1, {}, null, function filter(prop) {
     return /^is[A-Z]/.test(prop);
   });
-  function toFormData(obj, formData, options) {
+  function toFormData$1(obj, formData, options) {
     if (!utils$1.isObject(obj)) {
       throw new TypeError("target must be an object");
     }
@@ -784,7 +1584,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         return value.toISOString();
       }
       if (!useBlob && utils$1.isBlob(value)) {
-        throw new AxiosError("Blob is not supported. Use a Buffer instead.");
+        throw new AxiosError$1("Blob is not supported. Use a Buffer instead.");
       }
       if (utils$1.isArrayBuffer(value) || utils$1.isTypedArray(value)) {
         return useBlob && typeof Blob === "function" ? new Blob([value]) : Buffer.from(value);
@@ -863,7 +1663,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   }
   function AxiosURLSearchParams(params, options) {
     this._pairs = [];
-    params && toFormData(params, this, options);
+    params && toFormData$1(params, this, options);
   }
   const prototype = AxiosURLSearchParams.prototype;
   prototype.append = function append(name, value) {
@@ -1005,7 +1805,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     ...platform$1
   };
   function toURLEncodedForm(data, options) {
-    return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({
+    return toFormData$1(data, new platform.classes.URLSearchParams(), Object.assign({
       visitor: function(value, key, path, helpers) {
         if (platform.isNode && utils$1.isBuffer(value)) {
           this.append(key, value.toString("base64"));
@@ -1109,7 +1909,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         }
         if ((isFileList2 = utils$1.isFileList(data)) || contentType.indexOf("multipart/form-data") > -1) {
           const _FormData = this.env && this.env.FormData;
-          return toFormData(
+          return toFormData$1(
             isFileList2 ? { "files[]": data } : data,
             _FormData && new _FormData(),
             this.formSerializer
@@ -1137,7 +1937,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         } catch (e) {
           if (strictJSONParsing) {
             if (e.name === "SyntaxError") {
-              throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);
+              throw AxiosError$1.from(e, AxiosError$1.ERR_BAD_RESPONSE, this, null, this.response);
             }
             throw e;
           }
@@ -1265,7 +2065,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       });
     });
   }
-  class AxiosHeaders {
+  let AxiosHeaders$1 = class AxiosHeaders {
     constructor(headers) {
       headers && this.set(headers);
     }
@@ -1420,9 +2220,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       utils$1.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
       return this;
     }
-  }
-  AxiosHeaders.accessor(["Content-Type", "Content-Length", "Accept", "Accept-Encoding", "User-Agent", "Authorization"]);
-  utils$1.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => {
+  };
+  AxiosHeaders$1.accessor(["Content-Type", "Content-Length", "Accept", "Accept-Encoding", "User-Agent", "Authorization"]);
+  utils$1.reduceDescriptors(AxiosHeaders$1.prototype, ({ value }, key) => {
     let mapped = key[0].toUpperCase() + key.slice(1);
     return {
       get: () => value,
@@ -1431,11 +2231,11 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       }
     };
   });
-  utils$1.freezeMethods(AxiosHeaders);
+  utils$1.freezeMethods(AxiosHeaders$1);
   function transformData(fns, response) {
     const config = this || defaults;
     const context = response || config;
-    const headers = AxiosHeaders.from(context.headers);
+    const headers = AxiosHeaders$1.from(context.headers);
     let data = context.data;
     utils$1.forEach(fns, function transform(fn) {
       data = fn.call(config, data, headers.normalize(), response ? response.status : void 0);
@@ -1443,14 +2243,14 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     headers.normalize();
     return data;
   }
-  function isCancel(value) {
+  function isCancel$1(value) {
     return !!(value && value.__CANCEL__);
   }
-  function CanceledError(message, config, request) {
-    AxiosError.call(this, message == null ? "canceled" : message, AxiosError.ERR_CANCELED, config, request);
+  function CanceledError$1(message, config, request) {
+    AxiosError$1.call(this, message == null ? "canceled" : message, AxiosError$1.ERR_CANCELED, config, request);
     this.name = "CanceledError";
   }
-  utils$1.inherits(CanceledError, AxiosError, {
+  utils$1.inherits(CanceledError$1, AxiosError$1, {
     __CANCEL__: true
   });
   function settle(resolve, reject, response) {
@@ -1458,9 +2258,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     if (!response.status || !validateStatus || validateStatus(response.status)) {
       resolve(response);
     } else {
-      reject(new AxiosError(
+      reject(new AxiosError$1(
         "Request failed with status code " + response.status,
-        [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
+        [AxiosError$1.ERR_BAD_REQUEST, AxiosError$1.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
         response.config,
         response.request,
         response
@@ -1619,8 +2419,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     }
     return requestedURL;
   }
-  const headersToObject = (thing) => thing instanceof AxiosHeaders ? { ...thing } : thing;
-  function mergeConfig(config1, config2) {
+  const headersToObject = (thing) => thing instanceof AxiosHeaders$1 ? { ...thing } : thing;
+  function mergeConfig$1(config1, config2) {
     config2 = config2 || {};
     const config = {};
     function getMergedValue(target, source, prop, caseless) {
@@ -1698,9 +2498,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     return config;
   }
   const resolveConfig = (config) => {
-    const newConfig = mergeConfig({}, config);
+    const newConfig = mergeConfig$1({}, config);
     let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
-    newConfig.headers = headers = AxiosHeaders.from(headers);
+    newConfig.headers = headers = AxiosHeaders$1.from(headers);
     newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url), config.params, config.paramsSerializer);
     if (auth) {
       headers.set(
@@ -1733,7 +2533,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     return new Promise(function dispatchXhrRequest(resolve, reject) {
       const _config = resolveConfig(config);
       let requestData = _config.data;
-      const requestHeaders = AxiosHeaders.from(_config.headers).normalize();
+      const requestHeaders = AxiosHeaders$1.from(_config.headers).normalize();
       let { responseType, onUploadProgress, onDownloadProgress } = _config;
       let onCanceled;
       let uploadThrottled, downloadThrottled;
@@ -1751,7 +2551,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         if (!request) {
           return;
         }
-        const responseHeaders = AxiosHeaders.from(
+        const responseHeaders = AxiosHeaders$1.from(
           "getAllResponseHeaders" in request && request.getAllResponseHeaders()
         );
         const responseData = !responseType || responseType === "text" || responseType === "json" ? request.responseText : request.response;
@@ -1789,11 +2589,11 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         if (!request) {
           return;
         }
-        reject(new AxiosError("Request aborted", AxiosError.ECONNABORTED, config, request));
+        reject(new AxiosError$1("Request aborted", AxiosError$1.ECONNABORTED, config, request));
         request = null;
       };
       request.onerror = function handleError() {
-        reject(new AxiosError("Network Error", AxiosError.ERR_NETWORK, config, request));
+        reject(new AxiosError$1("Network Error", AxiosError$1.ERR_NETWORK, config, request));
         request = null;
       };
       request.ontimeout = function handleTimeout() {
@@ -1802,9 +2602,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         if (_config.timeoutErrorMessage) {
           timeoutErrorMessage = _config.timeoutErrorMessage;
         }
-        reject(new AxiosError(
+        reject(new AxiosError$1(
           timeoutErrorMessage,
-          transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,
+          transitional.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED,
           config,
           request
         ));
@@ -1836,7 +2636,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           if (!request) {
             return;
           }
-          reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);
+          reject(!cancel || cancel.type ? new CanceledError$1(null, config, request) : cancel);
           request.abort();
           request = null;
         };
@@ -1847,7 +2647,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       }
       const protocol = parseProtocol(_config.url);
       if (protocol && platform.protocols.indexOf(protocol) === -1) {
-        reject(new AxiosError("Unsupported protocol " + protocol + ":", AxiosError.ERR_BAD_REQUEST, config));
+        reject(new AxiosError$1("Unsupported protocol " + protocol + ":", AxiosError$1.ERR_BAD_REQUEST, config));
         return;
       }
       request.send(requestData || null);
@@ -1863,12 +2663,12 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           aborted = true;
           unsubscribe();
           const err = reason instanceof Error ? reason : this.reason;
-          controller.abort(err instanceof AxiosError ? err : new CanceledError(err instanceof Error ? err.message : err));
+          controller.abort(err instanceof AxiosError$1 ? err : new CanceledError$1(err instanceof Error ? err.message : err));
         }
       };
       let timer = timeout && setTimeout(() => {
         timer = null;
-        onabort(new AxiosError(`timeout ${timeout} of ms exceeded`, AxiosError.ETIMEDOUT));
+        onabort(new AxiosError$1(`timeout ${timeout} of ms exceeded`, AxiosError$1.ETIMEDOUT));
       }, timeout);
       const unsubscribe = () => {
         if (signals) {
@@ -1991,7 +2791,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   isFetchSupported && ((res) => {
     ["text", "arrayBuffer", "blob", "formData", "stream"].forEach((type) => {
       !resolvers[type] && (resolvers[type] = utils$1.isFunction(res[type]) ? (res2) => res2[type]() : (_, config) => {
-        throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);
+        throw new AxiosError$1(`Response type '${type}' is not supported`, AxiosError$1.ERR_NOT_SUPPORT, config);
       });
     });
   })(new Response());
@@ -2103,7 +2903,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       return await new Promise((resolve, reject) => {
         settle(resolve, reject, {
           data: responseData,
-          headers: AxiosHeaders.from(response.headers),
+          headers: AxiosHeaders$1.from(response.headers),
           status: response.status,
           statusText: response.statusText,
           config,
@@ -2114,13 +2914,13 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       unsubscribe && unsubscribe();
       if (err && err.name === "TypeError" && /fetch/i.test(err.message)) {
         throw Object.assign(
-          new AxiosError("Network Error", AxiosError.ERR_NETWORK, config, request),
+          new AxiosError$1("Network Error", AxiosError$1.ERR_NETWORK, config, request),
           {
             cause: err.cause || err
           }
         );
       }
-      throw AxiosError.from(err, err && err.code, config, request);
+      throw AxiosError$1.from(err, err && err.code, config, request);
     }
   });
   const knownAdapters = {
@@ -2153,7 +2953,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         if (!isResolvedHandle(nameOrAdapter)) {
           adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
           if (adapter === void 0) {
-            throw new AxiosError(`Unknown adapter '${id}'`);
+            throw new AxiosError$1(`Unknown adapter '${id}'`);
           }
         }
         if (adapter) {
@@ -2166,7 +2966,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           ([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(
+        throw new AxiosError$1(
           `There is no suitable adapter to dispatch the request ` + s,
           "ERR_NOT_SUPPORT"
         );
@@ -2180,12 +2980,12 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       config.cancelToken.throwIfRequested();
     }
     if (config.signal && config.signal.aborted) {
-      throw new CanceledError(null, config);
+      throw new CanceledError$1(null, config);
     }
   }
   function dispatchRequest(config) {
     throwIfCancellationRequested(config);
-    config.headers = AxiosHeaders.from(config.headers);
+    config.headers = AxiosHeaders$1.from(config.headers);
     config.data = transformData.call(
       config,
       config.transformRequest
@@ -2201,10 +3001,10 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         config.transformResponse,
         response
       );
-      response.headers = AxiosHeaders.from(response.headers);
+      response.headers = AxiosHeaders$1.from(response.headers);
       return response;
     }, function onAdapterRejection(reason) {
-      if (!isCancel(reason)) {
+      if (!isCancel$1(reason)) {
         throwIfCancellationRequested(config);
         if (reason && reason.response) {
           reason.response.data = transformData.call(
@@ -2212,13 +3012,13 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
             config.transformResponse,
             reason.response
           );
-          reason.response.headers = AxiosHeaders.from(reason.response.headers);
+          reason.response.headers = AxiosHeaders$1.from(reason.response.headers);
         }
       }
       return Promise.reject(reason);
     });
   }
-  const VERSION = "1.7.9";
+  const VERSION$1 = "1.7.9";
   const validators$1 = {};
   ["object", "boolean", "number", "function", "string", "symbol"].forEach((type, i) => {
     validators$1[type] = function validator2(thing) {
@@ -2228,13 +3028,13 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   const deprecatedWarnings = {};
   validators$1.transitional = function transitional(validator2, version, message) {
     function formatMessage(opt, desc) {
-      return "[Axios v" + VERSION + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+      return "[Axios v" + VERSION$1 + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
     }
     return (value, opt, opts) => {
       if (validator2 === false) {
-        throw new AxiosError(
+        throw new AxiosError$1(
           formatMessage(opt, " has been removed" + (version ? " in " + version : "")),
-          AxiosError.ERR_DEPRECATED
+          AxiosError$1.ERR_DEPRECATED
         );
       }
       if (version && !deprecatedWarnings[opt]) {
@@ -2257,7 +3057,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   };
   function assertOptions(options, schema, allowUnknown) {
     if (typeof options !== "object") {
-      throw new AxiosError("options must be an object", AxiosError.ERR_BAD_OPTION_VALUE);
+      throw new AxiosError$1("options must be an object", AxiosError$1.ERR_BAD_OPTION_VALUE);
     }
     const keys = Object.keys(options);
     let i = keys.length;
@@ -2268,12 +3068,12 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         const value = options[opt];
         const result = value === void 0 || validator2(value, opt, options);
         if (result !== true) {
-          throw new AxiosError("option " + opt + " must be " + result, AxiosError.ERR_BAD_OPTION_VALUE);
+          throw new AxiosError$1("option " + opt + " must be " + result, AxiosError$1.ERR_BAD_OPTION_VALUE);
         }
         continue;
       }
       if (allowUnknown !== true) {
-        throw new AxiosError("Unknown option " + opt, AxiosError.ERR_BAD_OPTION);
+        throw new AxiosError$1("Unknown option " + opt, AxiosError$1.ERR_BAD_OPTION);
       }
     }
   }
@@ -2282,7 +3082,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     validators: validators$1
   };
   const validators = validator.validators;
-  class Axios {
+  let Axios$1 = class Axios {
     constructor(instanceConfig) {
       this.defaults = instanceConfig;
       this.interceptors = {
@@ -2325,7 +3125,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       } else {
         config = configOrUrl || {};
       }
-      config = mergeConfig(this.defaults, config);
+      config = mergeConfig$1(this.defaults, config);
       const { transitional, paramsSerializer, headers } = config;
       if (transitional !== void 0) {
         validator.assertOptions(transitional, {
@@ -2361,7 +3161,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           delete headers[method];
         }
       );
-      config.headers = AxiosHeaders.concat(contextHeaders, headers);
+      config.headers = AxiosHeaders$1.concat(contextHeaders, headers);
       const requestInterceptorChain = [];
       let synchronousRequestInterceptors = true;
       this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
@@ -2415,14 +3215,14 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       return promise;
     }
     getUri(config) {
-      config = mergeConfig(this.defaults, config);
+      config = mergeConfig$1(this.defaults, config);
       const fullPath = buildFullPath(config.baseURL, config.url);
       return buildURL(fullPath, config.params, config.paramsSerializer);
     }
-  }
+  };
   utils$1.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) {
-    Axios.prototype[method] = function(url, config) {
-      return this.request(mergeConfig(config || {}, {
+    Axios$1.prototype[method] = function(url, config) {
+      return this.request(mergeConfig$1(config || {}, {
         method,
         url,
         data: (config || {}).data
@@ -2432,7 +3232,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   utils$1.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
     function generateHTTPMethod(isForm) {
       return function httpMethod(url, data, config) {
-        return this.request(mergeConfig(config || {}, {
+        return this.request(mergeConfig$1(config || {}, {
           method,
           headers: isForm ? {
             "Content-Type": "multipart/form-data"
@@ -2442,10 +3242,10 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         }));
       };
     }
-    Axios.prototype[method] = generateHTTPMethod();
-    Axios.prototype[method + "Form"] = generateHTTPMethod(true);
+    Axios$1.prototype[method] = generateHTTPMethod();
+    Axios$1.prototype[method + "Form"] = generateHTTPMethod(true);
   });
-  class CancelToken {
+  let CancelToken$1 = class CancelToken2 {
     constructor(executor) {
       if (typeof executor !== "function") {
         throw new TypeError("executor must be a function.");
@@ -2478,7 +3278,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         if (token.reason) {
           return;
         }
-        token.reason = new CanceledError(message, config, request);
+        token.reason = new CanceledError$1(message, config, request);
         resolvePromise(token.reason);
       });
     }
@@ -2531,7 +3331,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
      */
     static source() {
       let cancel;
-      const token = new CancelToken(function executor(c) {
+      const token = new CancelToken2(function executor(c) {
         cancel = c;
       });
       return {
@@ -2539,16 +3339,16 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         cancel
       };
     }
-  }
-  function spread(callback) {
+  };
+  function spread$1(callback) {
     return function wrap(arr) {
       return callback.apply(null, arr);
     };
   }
-  function isAxiosError(payload) {
+  function isAxiosError$1(payload) {
     return utils$1.isObject(payload) && payload.isAxiosError === true;
   }
-  const HttpStatusCode = {
+  const HttpStatusCode$1 = {
     Continue: 100,
     SwitchingProtocols: 101,
     Processing: 102,
@@ -2613,39 +3413,57 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     NotExtended: 510,
     NetworkAuthenticationRequired: 511
   };
-  Object.entries(HttpStatusCode).forEach(([key, value]) => {
-    HttpStatusCode[value] = key;
+  Object.entries(HttpStatusCode$1).forEach(([key, value]) => {
+    HttpStatusCode$1[value] = key;
   });
   function createInstance(defaultConfig) {
-    const context = new Axios(defaultConfig);
-    const instance = bind(Axios.prototype.request, context);
-    utils$1.extend(instance, Axios.prototype, context, { allOwnKeys: true });
+    const context = new Axios$1(defaultConfig);
+    const instance = bind(Axios$1.prototype.request, context);
+    utils$1.extend(instance, Axios$1.prototype, context, { allOwnKeys: true });
     utils$1.extend(instance, context, null, { allOwnKeys: true });
     instance.create = function create(instanceConfig) {
-      return createInstance(mergeConfig(defaultConfig, instanceConfig));
+      return createInstance(mergeConfig$1(defaultConfig, instanceConfig));
     };
     return instance;
   }
   const axios = createInstance(defaults);
-  axios.Axios = Axios;
-  axios.CanceledError = CanceledError;
-  axios.CancelToken = CancelToken;
-  axios.isCancel = isCancel;
-  axios.VERSION = VERSION;
-  axios.toFormData = toFormData;
-  axios.AxiosError = AxiosError;
+  axios.Axios = Axios$1;
+  axios.CanceledError = CanceledError$1;
+  axios.CancelToken = CancelToken$1;
+  axios.isCancel = isCancel$1;
+  axios.VERSION = VERSION$1;
+  axios.toFormData = toFormData$1;
+  axios.AxiosError = AxiosError$1;
   axios.Cancel = axios.CanceledError;
-  axios.all = function all(promises) {
+  axios.all = function all2(promises) {
     return Promise.all(promises);
   };
-  axios.spread = spread;
-  axios.isAxiosError = isAxiosError;
-  axios.mergeConfig = mergeConfig;
-  axios.AxiosHeaders = AxiosHeaders;
+  axios.spread = spread$1;
+  axios.isAxiosError = isAxiosError$1;
+  axios.mergeConfig = mergeConfig$1;
+  axios.AxiosHeaders = AxiosHeaders$1;
   axios.formToJSON = (thing) => formDataToJSON(utils$1.isHTMLForm(thing) ? new FormData(thing) : thing);
   axios.getAdapter = adapters.getAdapter;
-  axios.HttpStatusCode = HttpStatusCode;
+  axios.HttpStatusCode = HttpStatusCode$1;
   axios.default = axios;
+  const {
+    Axios,
+    AxiosError,
+    CanceledError,
+    isCancel,
+    CancelToken,
+    VERSION,
+    all,
+    Cancel,
+    isAxiosError,
+    spread,
+    toFormData,
+    AxiosHeaders,
+    HttpStatusCode,
+    formToJSON,
+    getAdapter,
+    mergeConfig
+  } = axios;
   class MemoryCache {
     constructor(ttl) {
       __publicField(this, "cache", {});
@@ -2843,6 +3661,31 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       });
     }
   }
+  var RequestMethod = /* @__PURE__ */ ((RequestMethod2) => {
+    RequestMethod2["GET"] = "GET";
+    RequestMethod2["HEAD"] = "HEAD";
+    RequestMethod2["POST"] = "POST";
+    RequestMethod2["PUT"] = "PUT";
+    RequestMethod2["DELETE"] = "DELETE";
+    RequestMethod2["PATCH"] = "PATCH";
+    RequestMethod2["OPTIONS"] = "OPTIONS";
+    return RequestMethod2;
+  })(RequestMethod || {});
+  var VersioningType = /* @__PURE__ */ ((VersioningType2) => {
+    VersioningType2[VersioningType2["Uri"] = 0] = "Uri";
+    VersioningType2[VersioningType2["Header"] = 1] = "Header";
+    VersioningType2[VersioningType2["Query"] = 2] = "Query";
+    VersioningType2[VersioningType2["Custom"] = 3] = "Custom";
+    return VersioningType2;
+  })(VersioningType || {});
+  var CacheType = /* @__PURE__ */ ((CacheType2) => {
+    CacheType2[CacheType2["Memory"] = 0] = "Memory";
+    CacheType2[CacheType2["IndexDB"] = 1] = "IndexDB";
+    CacheType2[CacheType2["LocalStorage"] = 2] = "LocalStorage";
+    return CacheType2;
+  })(CacheType || {});
+  class Strategy {
+  }
   function createCache(type, ttl) {
     if (type === CacheType.Memory) {
       return new MemoryCache(ttl);
@@ -2857,99 +3700,378 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     }
     return void 0;
   }
-  const DEFAULT_CONFIG = {
-    timeout: 5e3,
-    // 默认开启内存缓存
-    CacheManage: {
-      type: CacheType.Memory,
-      // 默认缓存时间为5分钟(单位秒)
-      ttl: 300
+  const apiKey = (apiInstance) => {
+    const { version, method, url, params, headers } = apiInstance;
+    return `[${method}]${version ? `-v${version}` : ""}-${url}${params ? `-${recordToString(params)}` : ""}${headers ? `-${recordToString(headers)}` : ""}`;
+  };
+  function recordToString(record) {
+    return Object.keys(record).map((key) => {
+      return `${key}=${record[key]}`;
+    }).sort((a, b) => a.localeCompare(b)).join("&");
+  }
+  const versionHandlers = {
+    [VersioningType.Uri]: (version, versioning) => {
+      const prefix = versioning.prefix || "v";
+      return {
+        url: `${prefix}${version}`
+      };
+    },
+    [VersioningType.Header]: (version, versioning) => {
+      const headers = {
+        [versioning.header || "version"]: version
+      };
+      return {
+        headers
+      };
+    },
+    [VersioningType.Query]: (version, versioning) => {
+      const key = versioning.key || "version";
+      return {
+        params: {
+          [key]: version
+        }
+      };
+    },
+    [VersioningType.Custom]: (version, versioning) => {
+      return versioning.extractor({
+        version
+      });
     }
   };
+  function applyVersioning(version, versioning) {
+    const handler = versionHandlers[versioning.type];
+    return handler(
+      version,
+      versioning
+    );
+  }
+  const METHOD_KEY = Symbol("SNAIL_METHOD_KEY");
+  const API_CONFIG_KEY = Symbol("SNAIL_API_CONFIG_KEY");
+  const Api = (url = "", config) => {
+    return (target) => {
+      Reflect.defineMetadata(API_CONFIG_KEY, { url, ...config }, target);
+    };
+  };
+  const createMethodDecorator = (method) => {
+    return (path = "") => {
+      return (target, propertyKey) => {
+        if (target) {
+          Reflect.defineMetadata(METHOD_KEY, { method, path }, target, propertyKey);
+          return;
+        }
+        Reflect.metadata(METHOD_KEY, { method, path });
+      };
+    };
+  };
+  const Get = createMethodDecorator(RequestMethod.GET);
+  const Post = createMethodDecorator(RequestMethod.POST);
+  const Put = createMethodDecorator(RequestMethod.PUT);
+  const Delete = createMethodDecorator(RequestMethod.DELETE);
+  const Patch = createMethodDecorator(RequestMethod.PATCH);
+  const Options = createMethodDecorator(RequestMethod.OPTIONS);
+  const Head = createMethodDecorator(RequestMethod.HEAD);
+  const SERVER_CONFIG_KEY = Symbol("SANIL_SERVER_CONFIG_KEY");
+  const Server = (config) => {
+    return (target) => {
+      Reflect.defineMetadata(SERVER_CONFIG_KEY, config, target);
+    };
+  };
+  const STRATEGY_KEY = Symbol("SNAIL_STRATEGY_KEY");
+  const UseStrategy = (...strategies) => {
+    return (target, propertyKey) => {
+      const key = propertyKey ? `${STRATEGY_KEY.toString()}_${propertyKey}` : STRATEGY_KEY;
+      Reflect.defineMetadata(key, strategies, target);
+    };
+  };
+  const REQUEST_ARGS_KEY = Symbol("SNAIL_REQUEST_ARGS_KEY");
+  const Params = (key) => createArgsDecorator("params", key);
+  const Data = () => createArgsDecorator("data");
+  const createArgsDecorator = (type, key) => {
+    return (target, propertyKey, parameterIndex) => {
+      const args = Reflect.getMetadata(REQUEST_ARGS_KEY, target, propertyKey) || [];
+      args.push({ index: parameterIndex, type, key });
+      Reflect.defineMetadata(REQUEST_ARGS_KEY, args, target, propertyKey);
+    };
+  };
+  const VERSIONING_KEY = Symbol("SNAIL_VERSIONING_KEY");
+  const VERSION_KEY = Symbol("SNAIL_VERSION_KEY");
+  const Versioning = (options) => {
+    return (target) => {
+      Reflect.defineMetadata(VERSIONING_KEY, options, target);
+    };
+  };
+  const Version = (version) => {
+    return (target, propertyKey) => {
+      Reflect.defineMetadata(VERSION_KEY, version, target, propertyKey);
+    };
+  };
+  const CACHE_OPTIONS_KEY = Symbol("SNALI_CACHE_OPTIONS_KEY");
+  const Cache = (hitSource) => {
+    return (target, propertyKey) => {
+      const key = propertyKey ? `${CACHE_OPTIONS_KEY.toString()}_${propertyKey}` : CACHE_OPTIONS_KEY;
+      Reflect.defineMetadata(key, hitSource, target);
+    };
+  };
   class Snail {
-    constructor(options) {
+    constructor() {
       __publicField(this, "axiosInstance");
-      __publicField(this, "baseURL", "");
-      __publicField(this, "versioning");
-      __publicField(this, "options");
+      // private config: SnailConfig;
+      __publicField(this, "strategies", []);
       __publicField(this, "cacheStorage");
-      __publicField(this, "cacheSource", []);
-      const instance = this;
-      const SnailOptions = {
-        ...DEFAULT_CONFIG,
-        ...options
-      };
-      this.baseURL = SnailOptions.baseURL || "";
-      this.versioning = SnailOptions.Versioning;
-      this.options = SnailOptions;
-      instance.axiosInstance = axios.create({
-        baseURL: instance.baseURL,
-        timeout: instance.options.timeout || 5e3
+      __publicField(this, "version");
+      __publicField(this, "sourceMap", /* @__PURE__ */ new Map());
+    }
+    registerStrategy(strategy) {
+      this.strategies.push(strategy);
+    }
+    createApi(constructor) {
+      const instance = new constructor();
+      const serverConfig = this.getServerConfig();
+      const { baseURL, timeout, CacheManage, enableLog } = serverConfig;
+      enableLog && console.log("serverConfig:", serverConfig);
+      this.initAxios({ baseURL, timeout });
+      enableLog && console.log("CacheManage:", CacheManage);
+      this.initCacheManage(CacheManage);
+      const apiConfig = this.getApiConfig(constructor);
+      enableLog && console.log("ApiConfig:", apiConfig);
+      this.version = apiConfig.version;
+      return new Proxy(instance, {
+        get: (target, propertyKey) => {
+          enableLog && console.log("proxy:", target, "|", propertyKey);
+          if (typeof propertyKey !== "string") return;
+          const methodConfig = Reflect.getMetadata(
+            METHOD_KEY,
+            target,
+            propertyKey
+          );
+          if (!methodConfig) return target[propertyKey];
+          return async (...args) => {
+            const url = methodConfig.path == "" ? apiConfig.url : apiConfig.url + `/${methodConfig.path}`;
+            enableLog && console.log("url:", url);
+            let request = {
+              // baseURL: serverConfig.baseURL,
+              url,
+              method: methodConfig.method,
+              timeout: apiConfig.timeout ? apiConfig.timeout : serverConfig.timeout
+            };
+            request = {
+              ...request,
+              ...this.applyVersion(request, target, propertyKey)
+            };
+            enableLog && console.log("版本管理参数:", request);
+            const strategies = this.getStrategies(target, propertyKey);
+            const params = this.buildRequestArgs(target, propertyKey, args);
+            request = { ...request, ...params };
+            enableLog && console.log("构建请求参数：", request);
+            const requestStrategies = strategies.filter(
+              (strategy) => strategy.applyRequest
+            );
+            request = await this.applyStrategies(
+              request,
+              requestStrategies,
+              "request"
+            );
+            const hitSource = this.getHitSource(target, propertyKey);
+            enableLog && console.log("hitSource:", hitSource);
+            if (typeof hitSource == "string") {
+              this.setHitSource(request, hitSource);
+            }
+            if (hitSource !== null) {
+              const cachedResponse = await this.getCache(request, strategies);
+              if (cachedResponse) {
+                enableLog && console.warn("数据从缓存获取");
+                return this.handleResponse(cachedResponse, true);
+              }
+            }
+            try {
+              enableLog && console.log("send request:", request);
+              const response = await this.axiosInstance(request);
+              hitSource !== null && this.setCache(request, response);
+              this.expireCache(propertyKey);
+              return this.handleResponse(response, false);
+            } catch (error) {
+              return this.handleError(error);
+            }
+          };
+        }
       });
-      if (SnailOptions.requestInterceptors) {
-        instance.axiosInstance.interceptors.request.use(
-          (config) => {
-            var _a, _b;
-            const result = (_b = (_a = SnailOptions.requestInterceptors) == null ? void 0 : _a.onFulfilled) == null ? void 0 : _b.call(_a, config);
-            return result ? result : config;
-          },
-          SnailOptions.requestInterceptors.onRejected,
-          SnailOptions.requestInterceptors.options
+    }
+    buildRequestArgs(target, propertyKey, args) {
+      const requestArgs = { params: {}, data: {} };
+      const paramConfigs = Reflect.getMetadata(REQUEST_ARGS_KEY, target, propertyKey) || [];
+      paramConfigs.forEach(({ index, type, key }) => {
+        const value = args[index];
+        if (type === "params" && !key && typeof value === "object") {
+          requestArgs.params = { ...requestArgs.params, ...value };
+        }
+        if (type === "params" && key) {
+          requestArgs.params[key] = value;
+        }
+        if (type === "data" && !key && typeof value === "object") {
+          requestArgs.data = { ...requestArgs.data, ...value };
+        }
+        if (type === "data" && key) {
+          requestArgs.data[key] = value;
+        }
+      });
+      return requestArgs;
+    }
+    getStrategies(target, propertyKey) {
+      const serverStrategies = Reflect.getMetadata(STRATEGY_KEY, this.constructor) || [];
+      const classStrategies = Reflect.getMetadata(STRATEGY_KEY, target.constructor) || [];
+      const methodStrategies = Reflect.getMetadata(
+        `${STRATEGY_KEY.toString()}_${propertyKey}`,
+        target
+      ) || [];
+      const allStrategies = [
+        ...this.strategies,
+        ...serverStrategies,
+        ...classStrategies,
+        ...methodStrategies
+      ];
+      return allStrategies;
+    }
+    async applyStrategies(data, strategies, type = "request") {
+      return await strategies.reduce(async (result, strategy) => {
+        if (type == "response")
+          return await strategy.applyResponse(await result);
+        return await strategy.applyRequest(await result);
+      }, Promise.resolve(data));
+    }
+    applyVersion(request, target, propertyKey) {
+      const versioning = Reflect.getMetadata(
+        VERSIONING_KEY,
+        this.constructor
+      );
+      if (!versioning) return request;
+      const version = Reflect.getMetadata(VERSION_KEY, target, propertyKey);
+      const currentVersion = version || this.version || versioning.defaultVersion;
+      const { url, headers, params } = applyVersioning(
+        currentVersion,
+        versioning
+      );
+      const versionUrl = url ? `${url}/${request.url}` : request.url;
+      return { ...request, url: versionUrl, headers, params };
+    }
+    async getCache(request, strategies) {
+      var _a;
+      if (!this.cacheStorage) return void 0;
+      const cacheKey = apiKey(request);
+      const cached = await ((_a = this.cacheStorage) == null ? void 0 : _a.get(cacheKey));
+      if (cached && cached.error === null) {
+        let cacheResponse = {
+          data: cached.data,
+          status: 304,
+          headers: {},
+          statusText: "get response data from cache",
+          config: { headers: new AxiosHeaders() }
+        };
+        const responseStrategies = strategies.filter(
+          (strategy) => strategy.applyResponse
         );
-      }
-      if (SnailOptions.responseInterceptors) {
-        instance.axiosInstance.interceptors.response.use(
-          (response) => {
-            var _a, _b;
-            const result = (_b = (_a = SnailOptions.responseInterceptors) == null ? void 0 : _a.onFulfilled) == null ? void 0 : _b.call(_a, response);
-            return result ? result : response;
-          },
-          (error) => {
-            var _a, _b;
-            const result = (_b = (_a = SnailOptions.responseInterceptors) == null ? void 0 : _a.onRejected) == null ? void 0 : _b.call(_a, error);
-            return Promise.reject(result || error);
-          }
+        const strategyResponse = await this.applyStrategies(
+          cacheResponse,
+          responseStrategies,
+          "response"
         );
+        return strategyResponse;
       }
-      if (instance.options.CacheManage) {
-        const { type, ttl } = instance.options.CacheManage;
-        instance.cacheStorage = createCache(type, ttl || 300);
+    }
+    initCacheManage(options) {
+      if (!this.cacheStorage && options !== void 0) {
+        this.cacheStorage = createCache(options.type, options.ttl || 300);
       }
     }
-    Get(url, options) {
-      return new Api(RequestMethod.GET, url, this, options);
+    getHitSource(target, propertyKey) {
+      const methodHitSource = Reflect.getMetadata(
+        `${CACHE_OPTIONS_KEY.toString()}_${propertyKey}`,
+        target
+      );
+      if (methodHitSource !== void 0) return methodHitSource;
+      const apiHitSource = Reflect.getMetadata(
+        CACHE_OPTIONS_KEY,
+        target.constructor
+      );
+      return apiHitSource;
+    }
+    setHitSource(request, hitSource) {
+      const cacheKeys = this.sourceMap.get(hitSource);
+      const currentCacheKey = apiKey(request);
+      if (cacheKeys) {
+        cacheKeys.push(currentCacheKey);
+        this.sourceMap.set(hitSource, cacheKeys);
+      } else {
+        this.sourceMap.set(hitSource, [currentCacheKey]);
+      }
     }
-    Post(url, options) {
-      return new Api(RequestMethod.POST, url, this, options);
+    async setCache(request, response) {
+      var _a;
+      const cacheKey = apiKey(request);
+      await ((_a = this.cacheStorage) == null ? void 0 : _a.set(cacheKey, response.data));
+    }
+    async expireCache(hitSource) {
+      const keys = this.sourceMap.get(hitSource);
+      if (keys) {
+        Promise.all(
+          keys.map(async (key) => {
+            var _a;
+            await ((_a = this.cacheStorage) == null ? void 0 : _a.delete(key));
+          })
+        );
+      }
     }
-    Put(url, options) {
-      return new Api(RequestMethod.PUT, url, this, options);
+    getServerConfig() {
+      return Reflect.getMetadata(
+        SERVER_CONFIG_KEY,
+        this.constructor
+      );
     }
-    Delete(url, options) {
-      return new Api(RequestMethod.DELETE, url, this, options);
+    getApiConfig(constructor) {
+      return Reflect.getMetadata(API_CONFIG_KEY, constructor);
     }
-    Patch(url, options) {
-      return new Api(RequestMethod.PATCH, url, this, options);
+    initAxios(config) {
+      if (!this.axiosInstance) {
+        this.axiosInstance = axios.create({
+          baseURL: config.baseURL,
+          timeout: config.timeout
+        });
+      }
     }
-    Head(url, options) {
-      return new Api(RequestMethod.HEAD, url, this, options);
+    handleResponse(response, hitCache) {
+      return {
+        data: response.data,
+        error: null,
+        hitCache
+      };
     }
-    Options(url, options) {
-      return new Api(RequestMethod.OPTIONS, url, this, options);
+    handleError(error) {
+      return {
+        data: null,
+        error
+      };
     }
   }
-  const createSnail = (option) => {
-    return new Snail(option);
-  };
   exports2.Api = Api;
+  exports2.Cache = Cache;
   exports2.CacheType = CacheType;
+  exports2.Data = Data;
+  exports2.Delete = Delete;
+  exports2.Get = Get;
+  exports2.Head = Head;
+  exports2.Options = Options;
+  exports2.Params = Params;
+  exports2.Patch = Patch;
+  exports2.Post = Post;
+  exports2.Put = Put;
   exports2.RequestMethod = RequestMethod;
+  exports2.Server = Server;
   exports2.Snail = Snail;
+  exports2.Strategy = Strategy;
+  exports2.UseStrategy = UseStrategy;
+  exports2.Version = Version;
+  exports2.Versioning = Versioning;
   exports2.VersioningType = VersioningType;
   exports2.apiKey = apiKey;
-  exports2.createSnail = createSnail;
-  exports2.deepCopy = deepCopy;
-  exports2.getResponseDataFromCache = getResponseDataFromCache;
   exports2.recordToString = recordToString;
   Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
 });