@snail-js/api 0.1.1 → 0.1.3

package/dist/{snail-api.mjs → snail-api.js}

@@ -1,284 +1,1084 @@
 var __defProp = Object.defineProperty;
 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);
@@ -661,7 +1461,7 @@ const utils$1 = {
   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);
@@ -678,7 +1478,7 @@ function AxiosError(message, code, config, request, response) {
     this.status = response.status ? response.status : null;
   }
 }
-utils$1.inherits(AxiosError, Error, {
+utils$1.inherits(AxiosError$1, Error, {
   toJSON: function toJSON() {
     return {
       // Standard
@@ -699,7 +1499,7 @@ utils$1.inherits(AxiosError, Error, {
     };
   }
 });
-const prototype$1 = AxiosError.prototype;
+const prototype$1 = AxiosError$1.prototype;
 const descriptors = {};
 [
   "ERR_BAD_OPTION_VALUE",
@@ -718,16 +1518,16 @@ const descriptors = {};
 ].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 filter2(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);
@@ -753,7 +1553,7 @@ function isFlatArray(arr) {
 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");
   }
@@ -780,7 +1580,7 @@ function toFormData(obj, formData, options) {
       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);
@@ -859,7 +1659,7 @@ function encode$1(str) {
 }
 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) {
@@ -1001,7 +1801,7 @@ const platform = {
   ...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"));
@@ -1105,7 +1905,7 @@ const defaults = {
       }
       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
@@ -1133,7 +1933,7 @@ const defaults = {
       } 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;
         }
@@ -1261,7 +2061,7 @@ function buildAccessors(obj, header) {
     });
   });
 }
-class AxiosHeaders {
+let AxiosHeaders$1 = class AxiosHeaders {
   constructor(headers) {
     headers && this.set(headers);
   }
@@ -1416,9 +2216,9 @@ class AxiosHeaders {
     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,
@@ -1427,11 +2227,11 @@ utils$1.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => {
     }
   };
 });
-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);
@@ -1439,14 +2239,14 @@ function transformData(fns, response) {
   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) {
@@ -1454,9 +2254,9 @@ function settle(resolve, reject, response) {
   if (!response.status || !validateStatus2 || validateStatus2(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
@@ -1615,8 +2415,8 @@ function buildFullPath(baseURL, requestedURL) {
   }
   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) {
@@ -1694,9 +2494,9 @@ function mergeConfig(config1, config2) {
   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(
@@ -1729,7 +2529,7 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
   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;
@@ -1747,7 +2547,7 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
       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;
@@ -1785,11 +2585,11 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
       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() {
@@ -1798,9 +2598,9 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
       if (_config.timeoutErrorMessage) {
         timeoutErrorMessage = _config.timeoutErrorMessage;
       }
-      reject(new AxiosError(
+      reject(new AxiosError$1(
         timeoutErrorMessage,
-        transitional2.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,
+        transitional2.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED,
         config,
         request
       ));
@@ -1832,7 +2632,7 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
         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;
       };
@@ -1843,7 +2643,7 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
     }
     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);
@@ -1859,12 +2659,12 @@ const composeSignals = (signals, timeout) => {
         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) {
@@ -1987,7 +2787,7 @@ const resolvers = {
 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());
@@ -2099,7 +2899,7 @@ const fetchAdapter = isFetchSupported && (async (config) => {
     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,
@@ -2110,13 +2910,13 @@ const fetchAdapter = isFetchSupported && (async (config) => {
     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 = {
@@ -2149,7 +2949,7 @@ const adapters = {
       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) {
@@ -2162,7 +2962,7 @@ const adapters = {
         ([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"
       );
@@ -2176,12 +2976,12 @@ function throwIfCancellationRequested(config) {
     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
@@ -2197,10 +2997,10 @@ function dispatchRequest(config) {
       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(
@@ -2208,13 +3008,13 @@ function dispatchRequest(config) {
           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) {
@@ -2224,13 +3024,13 @@ const validators$1 = {};
 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]) {
@@ -2253,7 +3053,7 @@ validators$1.spelling = function spelling(correctSpelling) {
 };
 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;
@@ -2264,12 +3064,12 @@ function assertOptions(options, schema, allowUnknown) {
       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);
     }
   }
 }
@@ -2278,7 +3078,7 @@ const validator = {
   validators: validators$1
 };
 const validators = validator.validators;
-class Axios {
+let Axios$1 = class Axios {
   constructor(instanceConfig) {
     this.defaults = instanceConfig;
     this.interceptors = {
@@ -2321,7 +3121,7 @@ class Axios {
     } else {
       config = configOrUrl || {};
     }
-    config = mergeConfig(this.defaults, config);
+    config = mergeConfig$1(this.defaults, config);
     const { transitional: transitional2, paramsSerializer, headers } = config;
     if (transitional2 !== void 0) {
       validator.assertOptions(transitional2, {
@@ -2357,7 +3157,7 @@ class Axios {
         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) {
@@ -2411,14 +3211,14 @@ class Axios {
     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
@@ -2428,7 +3228,7 @@ utils$1.forEach(["delete", "get", "head", "options"], function forEachMethodNoDa
 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"
@@ -2438,10 +3238,10 @@ utils$1.forEach(["post", "put", "patch"], function forEachMethodWithData(method)
       }));
     };
   }
-  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 CancelToken {
   constructor(executor) {
     if (typeof executor !== "function") {
       throw new TypeError("executor must be a function.");
@@ -2474,7 +3274,7 @@ class CancelToken {
       if (token.reason) {
         return;
       }
-      token.reason = new CanceledError(message, config, request);
+      token.reason = new CanceledError$1(message, config, request);
       resolvePromise(token.reason);
     });
   }
@@ -2535,16 +3335,16 @@ class CancelToken {
       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,
@@ -2609,39 +3409,57 @@ const HttpStatusCode = {
   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) {
   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: Axios2,
+  AxiosError,
+  CanceledError,
+  isCancel,
+  CancelToken: CancelToken2,
+  VERSION,
+  all: all2,
+  Cancel,
+  isAxiosError,
+  spread,
+  toFormData,
+  AxiosHeaders: AxiosHeaders2,
+  HttpStatusCode,
+  formToJSON,
+  getAdapter,
+  mergeConfig
+} = axios;
 class MemoryCache {
   constructor(ttl) {
     __publicField(this, "cache", {});
@@ -2839,6 +3657,31 @@ class IndexDBCache {
     });
   }
 }
+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);
@@ -2853,99 +3696,378 @@ function createCache(type, ttl) {
   }
   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 AxiosHeaders2() }
+      };
+      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);
-};
 export {
   Api,
+  Cache,
   CacheType,
+  Data,
+  Delete,
+  Get,
+  Head,
+  Options,
+  Params,
+  Patch,
+  Post,
+  Put,
   RequestMethod,
+  Server,
   Snail,
+  Strategy,
+  UseStrategy,
+  Version,
+  Versioning,
   VersioningType,
   apiKey,
-  createSnail,
-  deepCopy,
-  getResponseDataFromCache,
   recordToString
 };