@snail-js/api 0.1.13 → 0.1.15

package/dist/snail-api.umd.cjs

@@ -1465,7 +1465,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     setImmediate: _setImmediate,
     asap
   };
-  function AxiosError$1(message, code, config, request, response) {
+  function AxiosError(message, code, config, request, response) {
     Error.call(this);
     if (Error.captureStackTrace) {
       Error.captureStackTrace(this, this.constructor);
@@ -1482,7 +1482,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       this.status = response.status ? response.status : null;
     }
   }
-  utils$1.inherits(AxiosError$1, Error, {
+  utils$1.inherits(AxiosError, Error, {
     toJSON: function toJSON() {
       return {
         // Standard
@@ -1503,7 +1503,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       };
     }
   });
-  const prototype$1 = AxiosError$1.prototype;
+  const prototype$1 = AxiosError.prototype;
   const descriptors = {};
   [
     "ERR_BAD_OPTION_VALUE",
@@ -1522,16 +1522,16 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   ].forEach((code) => {
     descriptors[code] = { value: code };
   });
-  Object.defineProperties(AxiosError$1, descriptors);
+  Object.defineProperties(AxiosError, descriptors);
   Object.defineProperty(prototype$1, "isAxiosError", { value: true });
-  AxiosError$1.from = (error, code, config, request, response, customProps) => {
+  AxiosError.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$1.call(axiosError, error.message, code, config, request, response);
+    AxiosError.call(axiosError, error.message, code, config, request, response);
     axiosError.cause = error;
     axiosError.name = error.name;
     customProps && Object.assign(axiosError, customProps);
@@ -1557,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$1(obj, formData, options) {
+  function toFormData(obj, formData, options) {
     if (!utils$1.isObject(obj)) {
       throw new TypeError("target must be an object");
     }
@@ -1584,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$1("Blob is not supported. Use a Buffer instead.");
+        throw new AxiosError("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);
@@ -1663,7 +1663,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   }
   function AxiosURLSearchParams(params, options) {
     this._pairs = [];
-    params && toFormData$1(params, this, options);
+    params && toFormData(params, this, options);
   }
   const prototype = AxiosURLSearchParams.prototype;
   prototype.append = function append(name, value) {
@@ -1805,7 +1805,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     ...platform$1
   };
   function toURLEncodedForm(data, options) {
-    return toFormData$1(data, new platform.classes.URLSearchParams(), Object.assign({
+    return toFormData(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"));
@@ -1909,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$1(
+          return toFormData(
             isFileList2 ? { "files[]": data } : data,
             _FormData && new _FormData(),
             this.formSerializer
@@ -1937,7 +1937,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         } catch (e) {
           if (strictJSONParsing) {
             if (e.name === "SyntaxError") {
-              throw AxiosError$1.from(e, AxiosError$1.ERR_BAD_RESPONSE, this, null, this.response);
+              throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);
             }
             throw e;
           }
@@ -2065,7 +2065,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       });
     });
   }
-  let AxiosHeaders$1 = class AxiosHeaders {
+  class AxiosHeaders {
     constructor(headers) {
       headers && this.set(headers);
     }
@@ -2220,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$1.accessor(["Content-Type", "Content-Length", "Accept", "Accept-Encoding", "User-Agent", "Authorization"]);
-  utils$1.reduceDescriptors(AxiosHeaders$1.prototype, ({ value }, key) => {
+  }
+  AxiosHeaders.accessor(["Content-Type", "Content-Length", "Accept", "Accept-Encoding", "User-Agent", "Authorization"]);
+  utils$1.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => {
     let mapped = key[0].toUpperCase() + key.slice(1);
     return {
       get: () => value,
@@ -2231,11 +2231,11 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       }
     };
   });
-  utils$1.freezeMethods(AxiosHeaders$1);
+  utils$1.freezeMethods(AxiosHeaders);
   function transformData(fns, response) {
     const config = this || defaults;
     const context = response || config;
-    const headers = AxiosHeaders$1.from(context.headers);
+    const headers = AxiosHeaders.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);
@@ -2243,14 +2243,14 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     headers.normalize();
     return data;
   }
-  function isCancel$1(value) {
+  function isCancel(value) {
     return !!(value && value.__CANCEL__);
   }
-  function CanceledError$1(message, config, request) {
-    AxiosError$1.call(this, message == null ? "canceled" : message, AxiosError$1.ERR_CANCELED, config, request);
+  function CanceledError(message, config, request) {
+    AxiosError.call(this, message == null ? "canceled" : message, AxiosError.ERR_CANCELED, config, request);
     this.name = "CanceledError";
   }
-  utils$1.inherits(CanceledError$1, AxiosError$1, {
+  utils$1.inherits(CanceledError, AxiosError, {
     __CANCEL__: true
   });
   function settle(resolve, reject, response) {
@@ -2258,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$1(
+      reject(new AxiosError(
         "Request failed with status code " + response.status,
-        [AxiosError$1.ERR_BAD_REQUEST, AxiosError$1.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
+        [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
         response.config,
         response.request,
         response
@@ -2419,8 +2419,8 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     }
     return requestedURL;
   }
-  const headersToObject = (thing) => thing instanceof AxiosHeaders$1 ? { ...thing } : thing;
-  function mergeConfig$1(config1, config2) {
+  const headersToObject = (thing) => thing instanceof AxiosHeaders ? { ...thing } : thing;
+  function mergeConfig(config1, config2) {
     config2 = config2 || {};
     const config = {};
     function getMergedValue(target, source, prop, caseless) {
@@ -2498,9 +2498,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     return config;
   }
   const resolveConfig = (config) => {
-    const newConfig = mergeConfig$1({}, config);
+    const newConfig = mergeConfig({}, config);
     let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
-    newConfig.headers = headers = AxiosHeaders$1.from(headers);
+    newConfig.headers = headers = AxiosHeaders.from(headers);
     newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url), config.params, config.paramsSerializer);
     if (auth) {
       headers.set(
@@ -2533,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$1.from(_config.headers).normalize();
+      const requestHeaders = AxiosHeaders.from(_config.headers).normalize();
       let { responseType, onUploadProgress, onDownloadProgress } = _config;
       let onCanceled;
       let uploadThrottled, downloadThrottled;
@@ -2551,7 +2551,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         if (!request) {
           return;
         }
-        const responseHeaders = AxiosHeaders$1.from(
+        const responseHeaders = AxiosHeaders.from(
           "getAllResponseHeaders" in request && request.getAllResponseHeaders()
         );
         const responseData = !responseType || responseType === "text" || responseType === "json" ? request.responseText : request.response;
@@ -2589,11 +2589,11 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         if (!request) {
           return;
         }
-        reject(new AxiosError$1("Request aborted", AxiosError$1.ECONNABORTED, config, request));
+        reject(new AxiosError("Request aborted", AxiosError.ECONNABORTED, config, request));
         request = null;
       };
       request.onerror = function handleError() {
-        reject(new AxiosError$1("Network Error", AxiosError$1.ERR_NETWORK, config, request));
+        reject(new AxiosError("Network Error", AxiosError.ERR_NETWORK, config, request));
         request = null;
       };
       request.ontimeout = function handleTimeout() {
@@ -2602,9 +2602,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         if (_config.timeoutErrorMessage) {
           timeoutErrorMessage = _config.timeoutErrorMessage;
         }
-        reject(new AxiosError$1(
+        reject(new AxiosError(
           timeoutErrorMessage,
-          transitional.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED,
+          transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,
           config,
           request
         ));
@@ -2636,7 +2636,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           if (!request) {
             return;
           }
-          reject(!cancel || cancel.type ? new CanceledError$1(null, config, request) : cancel);
+          reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);
           request.abort();
           request = null;
         };
@@ -2647,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$1("Unsupported protocol " + protocol + ":", AxiosError$1.ERR_BAD_REQUEST, config));
+        reject(new AxiosError("Unsupported protocol " + protocol + ":", AxiosError.ERR_BAD_REQUEST, config));
         return;
       }
       request.send(requestData || null);
@@ -2663,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$1 ? err : new CanceledError$1(err instanceof Error ? err.message : err));
+          controller.abort(err instanceof AxiosError ? err : new CanceledError(err instanceof Error ? err.message : err));
         }
       };
       let timer = timeout && setTimeout(() => {
         timer = null;
-        onabort(new AxiosError$1(`timeout ${timeout} of ms exceeded`, AxiosError$1.ETIMEDOUT));
+        onabort(new AxiosError(`timeout ${timeout} of ms exceeded`, AxiosError.ETIMEDOUT));
       }, timeout);
       const unsubscribe = () => {
         if (signals) {
@@ -2791,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$1(`Response type '${type}' is not supported`, AxiosError$1.ERR_NOT_SUPPORT, config);
+        throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);
       });
     });
   })(new Response());
@@ -2903,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$1.from(response.headers),
+          headers: AxiosHeaders.from(response.headers),
           status: response.status,
           statusText: response.statusText,
           config,
@@ -2914,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$1("Network Error", AxiosError$1.ERR_NETWORK, config, request),
+          new AxiosError("Network Error", AxiosError.ERR_NETWORK, config, request),
           {
             cause: err.cause || err
           }
         );
       }
-      throw AxiosError$1.from(err, err && err.code, config, request);
+      throw AxiosError.from(err, err && err.code, config, request);
     }
   });
   const knownAdapters = {
@@ -2953,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$1(`Unknown adapter '${id}'`);
+            throw new AxiosError(`Unknown adapter '${id}'`);
           }
         }
         if (adapter) {
@@ -2966,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$1(
+        throw new AxiosError(
           `There is no suitable adapter to dispatch the request ` + s,
           "ERR_NOT_SUPPORT"
         );
@@ -2980,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$1(null, config);
+      throw new CanceledError(null, config);
     }
   }
   function dispatchRequest(config) {
     throwIfCancellationRequested(config);
-    config.headers = AxiosHeaders$1.from(config.headers);
+    config.headers = AxiosHeaders.from(config.headers);
     config.data = transformData.call(
       config,
       config.transformRequest
@@ -3001,10 +3001,10 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         config.transformResponse,
         response
       );
-      response.headers = AxiosHeaders$1.from(response.headers);
+      response.headers = AxiosHeaders.from(response.headers);
       return response;
     }, function onAdapterRejection(reason) {
-      if (!isCancel$1(reason)) {
+      if (!isCancel(reason)) {
         throwIfCancellationRequested(config);
         if (reason && reason.response) {
           reason.response.data = transformData.call(
@@ -3012,13 +3012,13 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
             config.transformResponse,
             reason.response
           );
-          reason.response.headers = AxiosHeaders$1.from(reason.response.headers);
+          reason.response.headers = AxiosHeaders.from(reason.response.headers);
         }
       }
       return Promise.reject(reason);
     });
   }
-  const VERSION$1 = "1.7.9";
+  const VERSION = "1.7.9";
   const validators$1 = {};
   ["object", "boolean", "number", "function", "string", "symbol"].forEach((type, i) => {
     validators$1[type] = function validator2(thing) {
@@ -3028,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$1 + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+      return "[Axios v" + VERSION + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
     }
     return (value, opt, opts) => {
       if (validator2 === false) {
-        throw new AxiosError$1(
+        throw new AxiosError(
           formatMessage(opt, " has been removed" + (version ? " in " + version : "")),
-          AxiosError$1.ERR_DEPRECATED
+          AxiosError.ERR_DEPRECATED
         );
       }
       if (version && !deprecatedWarnings[opt]) {
@@ -3057,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$1("options must be an object", AxiosError$1.ERR_BAD_OPTION_VALUE);
+      throw new AxiosError("options must be an object", AxiosError.ERR_BAD_OPTION_VALUE);
     }
     const keys = Object.keys(options);
     let i = keys.length;
@@ -3068,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$1("option " + opt + " must be " + result, AxiosError$1.ERR_BAD_OPTION_VALUE);
+          throw new AxiosError("option " + opt + " must be " + result, AxiosError.ERR_BAD_OPTION_VALUE);
         }
         continue;
       }
       if (allowUnknown !== true) {
-        throw new AxiosError$1("Unknown option " + opt, AxiosError$1.ERR_BAD_OPTION);
+        throw new AxiosError("Unknown option " + opt, AxiosError.ERR_BAD_OPTION);
       }
     }
   }
@@ -3082,7 +3082,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     validators: validators$1
   };
   const validators = validator.validators;
-  let Axios$1 = class Axios {
+  class Axios {
     constructor(instanceConfig) {
       this.defaults = instanceConfig;
       this.interceptors = {
@@ -3125,7 +3125,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       } else {
         config = configOrUrl || {};
       }
-      config = mergeConfig$1(this.defaults, config);
+      config = mergeConfig(this.defaults, config);
       const { transitional, paramsSerializer, headers } = config;
       if (transitional !== void 0) {
         validator.assertOptions(transitional, {
@@ -3161,7 +3161,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           delete headers[method];
         }
       );
-      config.headers = AxiosHeaders$1.concat(contextHeaders, headers);
+      config.headers = AxiosHeaders.concat(contextHeaders, headers);
       const requestInterceptorChain = [];
       let synchronousRequestInterceptors = true;
       this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
@@ -3215,14 +3215,14 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       return promise;
     }
     getUri(config) {
-      config = mergeConfig$1(this.defaults, config);
+      config = mergeConfig(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$1.prototype[method] = function(url, config) {
-      return this.request(mergeConfig$1(config || {}, {
+    Axios.prototype[method] = function(url, config) {
+      return this.request(mergeConfig(config || {}, {
         method,
         url,
         data: (config || {}).data
@@ -3232,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$1(config || {}, {
+        return this.request(mergeConfig(config || {}, {
           method,
           headers: isForm ? {
             "Content-Type": "multipart/form-data"
@@ -3242,10 +3242,10 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         }));
       };
     }
-    Axios$1.prototype[method] = generateHTTPMethod();
-    Axios$1.prototype[method + "Form"] = generateHTTPMethod(true);
+    Axios.prototype[method] = generateHTTPMethod();
+    Axios.prototype[method + "Form"] = generateHTTPMethod(true);
   });
-  let CancelToken$1 = class CancelToken2 {
+  class CancelToken {
     constructor(executor) {
       if (typeof executor !== "function") {
         throw new TypeError("executor must be a function.");
@@ -3278,7 +3278,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         if (token.reason) {
           return;
         }
-        token.reason = new CanceledError$1(message, config, request);
+        token.reason = new CanceledError(message, config, request);
         resolvePromise(token.reason);
       });
     }
@@ -3331,7 +3331,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
      */
     static source() {
       let cancel;
-      const token = new CancelToken2(function executor(c) {
+      const token = new CancelToken(function executor(c) {
         cancel = c;
       });
       return {
@@ -3339,16 +3339,16 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         cancel
       };
     }
-  };
-  function spread$1(callback) {
+  }
+  function spread(callback) {
     return function wrap(arr) {
       return callback.apply(null, arr);
     };
   }
-  function isAxiosError$1(payload) {
+  function isAxiosError(payload) {
     return utils$1.isObject(payload) && payload.isAxiosError === true;
   }
-  const HttpStatusCode$1 = {
+  const HttpStatusCode = {
     Continue: 100,
     SwitchingProtocols: 101,
     Processing: 102,
@@ -3413,102 +3413,115 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     NotExtended: 510,
     NetworkAuthenticationRequired: 511
   };
-  Object.entries(HttpStatusCode$1).forEach(([key, value]) => {
-    HttpStatusCode$1[value] = key;
+  Object.entries(HttpStatusCode).forEach(([key, value]) => {
+    HttpStatusCode[value] = key;
   });
   function createInstance(defaultConfig) {
-    const context = new Axios$1(defaultConfig);
-    const instance = bind(Axios$1.prototype.request, context);
-    utils$1.extend(instance, Axios$1.prototype, context, { allOwnKeys: true });
+    const context = new Axios(defaultConfig);
+    const instance = bind(Axios.prototype.request, context);
+    utils$1.extend(instance, Axios.prototype, context, { allOwnKeys: true });
     utils$1.extend(instance, context, null, { allOwnKeys: true });
     instance.create = function create(instanceConfig) {
-      return createInstance(mergeConfig$1(defaultConfig, instanceConfig));
+      return createInstance(mergeConfig(defaultConfig, instanceConfig));
     };
     return instance;
   }
   const axios = createInstance(defaults);
-  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.Axios = Axios;
+  axios.CanceledError = CanceledError;
+  axios.CancelToken = CancelToken;
+  axios.isCancel = isCancel;
+  axios.VERSION = VERSION;
+  axios.toFormData = toFormData;
+  axios.AxiosError = AxiosError;
   axios.Cancel = axios.CanceledError;
-  axios.all = function all2(promises) {
+  axios.all = function all(promises) {
     return Promise.all(promises);
   };
-  axios.spread = spread$1;
-  axios.isAxiosError = isAxiosError$1;
-  axios.mergeConfig = mergeConfig$1;
-  axios.AxiosHeaders = AxiosHeaders$1;
+  axios.spread = spread;
+  axios.isAxiosError = isAxiosError;
+  axios.mergeConfig = mergeConfig;
+  axios.AxiosHeaders = AxiosHeaders;
   axios.formToJSON = (thing) => formDataToJSON(utils$1.isHTMLForm(thing) ? new FormData(thing) : thing);
   axios.getAdapter = adapters.getAdapter;
-  axios.HttpStatusCode = HttpStatusCode$1;
+  axios.HttpStatusCode = HttpStatusCode;
   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", {});
+      // private cache: Record<string, CacheSetData> = {};
+      __publicField(this, "CacheMap", /* @__PURE__ */ new Map());
       __publicField(this, "ttl");
       this.ttl = ttl;
     }
     async get(key) {
-      const cacheRecord = this.cache;
       return new Promise((resolve, reject) => {
         try {
-          const cacheItem = cacheRecord[key];
+          const cacheItem = this.CacheMap.get(key);
           if (!cacheItem) {
-            return resolve({ error: "[MemoryCache]未找到缓存，将执行请求", data: null });
+            return resolve({
+              error: new Error("[MemoryCache]未找到缓存，将执行请求"),
+              data: null
+            });
           }
           const { data, exp } = cacheItem;
           if (exp < Math.ceil((/* @__PURE__ */ new Date()).getTime() / 1e3)) {
             this.delete(key);
-            return resolve({ error: "[MemoryCache]缓存已过期，将执行请求", data: null });
+            return resolve({
+              error: new Error("[MemoryCache]缓存已过期，将执行请求"),
+              data: null
+            });
           }
           resolve({ error: null, data });
         } catch (error) {
-          reject({ error, data: null });
+          console.error("[MemoryCache]获取缓存错误：", error);
+          reject(error);
         }
       });
     }
     async set(key, value) {
       return new Promise((resolve, reject) => {
         try {
-          this.cache[key] = {
+          this.CacheMap.set(key, {
             data: value,
             exp: Math.ceil((/* @__PURE__ */ new Date()).getTime() / 1e3) + this.ttl
-          };
-          resolve({ error: null, data: true });
+          });
+          resolve(true);
         } catch (error) {
-          reject({ error, data: null });
+          console.error("[MemoryCache]设置缓存错误：", error);
+          reject(error);
         }
       });
     }
     async delete(key) {
       return new Promise((resolve, reject) => {
         try {
-          delete this.cache[key];
-          resolve({ error: null, data: true });
+          this.CacheMap.delete(key);
+          resolve(true);
         } catch (error) {
-          reject({ error, data: null });
+          console.error("[MemoryCache]删除缓存错误：", error);
+          reject(error);
+        }
+      });
+    }
+    async clear() {
+      return new Promise((resolve, reject) => {
+        try {
+          this.CacheMap.clear();
+          resolve(true);
+        } catch (error) {
+          console.error("[MemoryCache]清空缓存错误：", error);
+          reject(error);
+        }
+      });
+    }
+    async keys() {
+      return new Promise((resolve, reject) => {
+        try {
+          const keys = Array.from(this.CacheMap.keys());
+          resolve(keys);
+        } catch (error) {
+          console.error("[MemoryCache]获取缓存键错误：", error);
+          reject(error);
         }
       });
     }
@@ -3523,12 +3536,18 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         try {
           const cacheItem = localStorage.getItem(key);
           if (!cacheItem) {
-            return resolve({ error: `未找到${key}的缓存`, data: null });
+            return resolve({
+              error: new Error(`未找到${key}的缓存`),
+              data: null
+            });
           }
           const { data, exp } = JSON.parse(cacheItem);
           if (exp < Math.ceil((/* @__PURE__ */ new Date()).getTime() / 1e3)) {
             this.delete(key);
-            return resolve({ error: `${key}的缓存已过期`, data: null });
+            return resolve({
+              error: new Error(`${key}的缓存已过期`),
+              data: null
+            });
           }
           resolve({ error: null, data });
         } catch (error) {
@@ -3546,8 +3565,9 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
               exp: Math.ceil((/* @__PURE__ */ new Date()).getTime() / 1e3) + this.ttl
             })
           );
-          resolve({ error: null, data: true });
+          resolve(true);
         } catch (error) {
+          console.error("[LocalStorage]插入数据错误：", error);
           reject({ error, data: null });
         }
       });
@@ -3556,12 +3576,34 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       return new Promise((resolve, reject) => {
         try {
           localStorage.removeItem(key);
-          resolve({ error: null, data: true });
+          resolve(true);
         } catch (error) {
-          reject({ error, data: null });
+          console.error("[LocalStorage]删除数据错误：", error);
+          reject(error);
         }
       });
     }
+    async clear() {
+      return new Promise((resolve, reject) => {
+        try {
+          localStorage.clear();
+          resolve(true);
+        } catch (error) {
+          console.error("[LocalStorage]清空数据错误：", error);
+          reject(false);
+        }
+      });
+    }
+    async keys() {
+      return new Promise((resolve) => {
+        const keys = [];
+        for (let i = 0; i < localStorage.length; i++) {
+          const key = localStorage.key(i);
+          if (key) keys.push(key);
+        }
+        resolve(keys);
+      });
+    }
   }
   const INDEXDB_DATABASE_NAME = "SNAIL_CACHE";
   const INDEXDB_VERSION = 3;
@@ -3631,13 +3673,11 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
           key
         });
         select.onsuccess = () => {
-          resolve({ error: null, data: true });
+          resolve(true);
         };
         select.onerror = (event) => {
-          reject({
-            error: new Error(`插入数据错误：${event.target}`),
-            data: null
-          });
+          console.error(`[indexDB]插入数据错误：${event.target}`);
+          reject(event);
         };
       });
     }
@@ -3648,27 +3688,49 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
         }
         const select = this.db.transaction(INDEXDB_OBJECT_STORE_NAME, "readwrite").objectStore(INDEXDB_OBJECT_STORE_NAME).delete(key);
         select.onsuccess = () => {
-          resolve({ error: null, data: true });
+          resolve(true);
         };
         select.onerror = (event) => {
-          reject({
-            error: new Error(`删除数据错误：${event.target}`),
-            data: null
-          });
+          console.error(`[indexDB]删除数据错误：${event.target}`);
+          reject(event);
+        };
+      });
+    }
+    async clear() {
+      return new Promise(async (resolve, reject) => {
+        if (!this.db) await this.init();
+        const transaction = this.db.transaction(INDEXDB_OBJECT_STORE_NAME, "readwrite");
+        const request = transaction.objectStore(INDEXDB_OBJECT_STORE_NAME).clear();
+        request.onsuccess = () => resolve(true);
+        request.onerror = (event) => {
+          console.error(`[indexDB]清空数据错误：${event.target}`);
+          reject(false);
+        };
+      });
+    }
+    async keys() {
+      return new Promise(async (resolve, reject) => {
+        if (!this.db) await this.init();
+        const transaction = this.db.transaction(INDEXDB_OBJECT_STORE_NAME, "readonly");
+        const request = transaction.objectStore(INDEXDB_OBJECT_STORE_NAME).getAllKeys();
+        request.onsuccess = () => resolve(request.result.map((key) => key.toString()));
+        request.onerror = (event) => {
+          console.error(`[indexDB]获取键名错误：${event.target}`);
+          reject([]);
         };
       });
     }
   }
-  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 RequestMethodEnum = /* @__PURE__ */ ((RequestMethodEnum2) => {
+    RequestMethodEnum2["GET"] = "Get";
+    RequestMethodEnum2["HEAD"] = "Head";
+    RequestMethodEnum2["POST"] = "Post";
+    RequestMethodEnum2["PUT"] = "Put";
+    RequestMethodEnum2["DELETE"] = "delete";
+    RequestMethodEnum2["PATCH"] = "Patch";
+    RequestMethodEnum2["OPTIONS"] = "Options";
+    return RequestMethodEnum2;
+  })(RequestMethodEnum || {});
   var VersioningType = /* @__PURE__ */ ((VersioningType2) => {
     VersioningType2[VersioningType2["Uri"] = 0] = "Uri";
     VersioningType2[VersioningType2["Header"] = 1] = "Header";
@@ -3680,36 +3742,70 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     CacheType2[CacheType2["Memory"] = 0] = "Memory";
     CacheType2[CacheType2["IndexDB"] = 1] = "IndexDB";
     CacheType2[CacheType2["LocalStorage"] = 2] = "LocalStorage";
+    CacheType2[CacheType2["Custom"] = 3] = "Custom";
     return CacheType2;
   })(CacheType || {});
+  class CacheStorageAdapter {
+  }
   class Strategy {
   }
-  class RegisterSseEvent {
+  class SseEventListener {
     constructor() {
       __publicField(this, "eventName");
       __publicField(this, "emit");
       __publicField(this, "options");
     }
   }
-  function createCache(type, ttl) {
-    if (type === CacheType.Memory) {
-      return new MemoryCache(ttl);
+  class SseOptions {
+    constructor() {
+      __publicField(this, "withCredentials");
+      __publicField(this, "version");
+    }
+  }
+  var EventType = /* @__PURE__ */ ((EventType2) => {
+    EventType2["Success"] = "success";
+    EventType2["Error"] = "error";
+    EventType2["hitCache"] = "hitCache";
+    EventType2["Finish"] = "finish";
+    return EventType2;
+  })(EventType || {});
+  function createCache(optios) {
+    const { type } = optios;
+    if (type === CacheType.Custom) {
+      const adapter = optios.adapter;
+      return new adapter(optios.options);
     }
     if (type === CacheType.LocalStorage) {
-      return new LocalStorageCache(ttl);
+      const { ttl: ttl2 } = optios;
+      return new LocalStorageCache(ttl2);
     }
     if (type === CacheType.IndexDB) {
-      const db = new IndexDBCache(ttl);
+      const { ttl: ttl2 } = optios;
+      const db = new IndexDBCache(ttl2);
       db.init();
       return db;
     }
-    return void 0;
+    const { ttl } = optios;
+    return new MemoryCache(ttl);
   }
-  const apiKey = (apiInstance) => {
-    const { version, method, url, params, headers } = apiInstance;
-    const str = `${params ? `-${recordToString(params)}` : ""}${headers ? `-${recordToString(headers)}` : ""}`;
-    return `[${method}]${version ? `-v${version}` : ""}-${url}-${generateShortUniqueHash(str)}`;
+  const REQUEST_ARGS_KEY = Symbol("SNAIL_REQUEST_ARGS_KEY");
+  const Params = (key) => createArgsDecorator("params", key);
+  const Query = (key) => createArgsDecorator("querys", key);
+  const Data = (key) => createArgsDecorator("data", key);
+  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);
+    };
   };
+  async function generateCacheKey(methodName, version, request) {
+    const { method, url, params, headers } = request;
+    const hash = await generateShortUniqueHash(
+      `${params ? `-${recordToString(params)}` : ""}${headers ? `-${recordToString(headers)}` : ""}`
+    );
+    return `${methodName}${version ? `[v${version}]` : ""}[${method}]${url}-${hash}`;
+  }
   async function generateShortUniqueHash(str) {
     const encoder = new TextEncoder();
     const data = encoder.encode(str);
@@ -3724,42 +3820,73 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       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 replacePlaceholders(route, values) {
+    const placeholderRegex = /:([a-zA-Z0-9_]+)/g;
+    const newRoute = route.replace(placeholderRegex, (match, key) => {
+      if (values.hasOwnProperty(key)) {
+        return values[key];
+      } else {
+        console.error(`路由[${route}]中的占位符${match}，没有对应的值`);
+        console.error(`请在该路由对应的方法中添加@Params('${key}')装饰器`);
+        throw new TypeError(`route params error in ${route}`);
+      }
+    });
+    return newRoute;
+  }
+  const resolveUrl = (url) => {
+    if (!url) return "";
+    if (url.startsWith("/")) return url;
+    return `/${url}`;
   };
-  function applyVersioning(version, versioning) {
-    const handler = versionHandlers[versioning.type];
-    return handler(
-      version,
-      versioning
+  async function applyStrategies(data, strategies, type = "request") {
+    return await strategies.reduce(
+      async (result, strategy) => {
+        let handler;
+        const instance = new strategy();
+        if (type == "response") {
+          handler = instance.applyResponse;
+        }
+        handler = instance.applyRequest;
+        const currentResult = handler(await result);
+        if (!currentResult) return result;
+        return currentResult;
+      },
+      Promise.resolve(data)
     );
   }
+  const SnailPass = (...args) => {
+  };
+  const buildRequestArgs = (target, propertyKey, args) => {
+    const requestArgs = { params: {}, data: {}, querys: {} };
+    const argsConfigs = Reflect.getMetadata(REQUEST_ARGS_KEY, target, propertyKey) || [];
+    console.log("argsConfigs:", argsConfigs);
+    argsConfigs.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 === "querys" && !key && typeof value === "object") {
+        requestArgs.querys = { ...requestArgs.params, ...value };
+      }
+      if (type === "querys" && key) {
+        requestArgs.querys[key] = value;
+      }
+      if (type === "data" && !key && typeof value === "object") {
+        requestArgs.data = { ...requestArgs.data, ...value };
+      }
+      if (type === "data" && key) {
+        requestArgs.data[key] = value;
+      }
+    });
+    return requestArgs;
+  };
+  function isSpecialResponse(response) {
+    const contentType = response.headers["content-type"];
+    return contentType && contentType.includes("application/json");
+  }
   const METHOD_KEY = Symbol("SNAIL_METHOD_KEY");
   const API_CONFIG_KEY = Symbol("SNAIL_API_CONFIG_KEY");
   const Api = (url = "", config) => {
@@ -3768,23 +3895,34 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
     };
   };
   const createMethodDecorator = (method) => {
-    return (path = "") => {
+    return (path = "", name) => {
       return (target, propertyKey) => {
-        if (target) {
-          Reflect.defineMetadata(METHOD_KEY, { method, path }, target, propertyKey);
-          return;
+        const methodOptions = Reflect.getMetadata(
+          METHOD_KEY,
+          target,
+          propertyKey
+        );
+        if (methodOptions) {
+          console.error("only one method decorator for a request function!");
+          console.error(`you must chose only one method decorator[@${method} or @${methodOptions.method}]`);
+          throw new TypeError(`Multiple decorators are used for the same request function`);
         }
-        Reflect.metadata(METHOD_KEY, { method, path });
+        Reflect.defineMetadata(
+          METHOD_KEY,
+          { method, path, name },
+          target,
+          propertyKey
+        );
       };
     };
   };
-  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 Get = createMethodDecorator(RequestMethodEnum.GET);
+  const Post = createMethodDecorator(RequestMethodEnum.POST);
+  const Put = createMethodDecorator(RequestMethodEnum.PUT);
+  const Delete = createMethodDecorator(RequestMethodEnum.DELETE);
+  const Patch = createMethodDecorator(RequestMethodEnum.PATCH);
+  const Options = createMethodDecorator(RequestMethodEnum.OPTIONS);
+  const Head = createMethodDecorator(RequestMethodEnum.HEAD);
   const SERVER_CONFIG_KEY = Symbol("SANIL_SERVER_CONFIG_KEY");
   const Server = (config) => {
     return (target) => {
@@ -3798,16 +3936,6 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       Reflect.defineMetadata(key, strategies, target);
     };
   };
-  const REQUEST_ARGS_KEY = Symbol("SNAIL_REQUEST_ARGS_KEY");
-  const Params = (key) => createArgsDecorator("params", key);
-  const Data = (key) => createArgsDecorator("data", key);
-  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) => {
@@ -3820,389 +3948,844 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
       Reflect.defineMetadata(VERSION_KEY, version, target, propertyKey);
     };
   };
-  const CACHE_OPTIONS_KEY = Symbol("SNALI_CACHE_OPTIONS_KEY");
-  const Cache = (hitSource) => {
+  const NO_CACHE_KEY = Symbol("SNALI_NO_CACHE_KEY");
+  const CACHE_EXPIRE_SOURCE_KEY = Symbol("SNALI_CACHE_EXPIRE_SOURCE_KEY");
+  const NoCache = () => {
     return (target, propertyKey) => {
-      const key = propertyKey ? `${CACHE_OPTIONS_KEY.toString()}_${propertyKey}` : CACHE_OPTIONS_KEY;
-      Reflect.defineMetadata(key, hitSource, target);
+      if (propertyKey) {
+        Reflect.defineMetadata(NO_CACHE_KEY, true, target, propertyKey);
+        return;
+      }
+      Reflect.defineMetadata(NO_CACHE_KEY, true, target);
     };
   };
-  const UPLOAD_PROGRESS_KEY = Symbol("SNAIL_UPLOAD_PROGRESS_KEY");
-  const DOWNLOAD_PROGRESS_KEY = Symbol("SNAIL_DOWNLOAD_PROGRESS_KEY");
-  const EVENT_SOURCE_OPTION_KEY = Symbol("SNAIL_EVENT_SOURCE_OPTION_KEY");
-  const Sse = (path, options) => {
+  const HitSource = (...sources) => {
     return (target, propertyKey) => {
-      Reflect.defineMetadata(
-        EVENT_SOURCE_OPTION_KEY,
-        {
-          path,
-          withCredentials: options == null ? void 0 : options.withCredentials
-        },
-        target,
-        propertyKey
-      );
+      if (propertyKey) {
+        Reflect.defineMetadata(
+          CACHE_EXPIRE_SOURCE_KEY,
+          sources,
+          target,
+          propertyKey
+        );
+        return;
+      }
+      Reflect.defineMetadata(CACHE_EXPIRE_SOURCE_KEY, sources, target);
     };
   };
-  const EVENT_SOURCE_EVENTS_KEY = Symbol("EVENT_SOURCE_EVENTS_KEY");
-  const SseEvent = (eventName, options) => {
-    return (target, propertyKey) => {
-      const events = Reflect.getMetadata(EVENT_SOURCE_EVENTS_KEY, target) || [];
-      events.push({
-        eventName: eventName ? eventName : "message",
-        emit: target[propertyKey],
-        options
+  const versionHandlers = {
+    [VersioningType.Uri]: (version, versioning) => {
+      const prefix = versioning.prefix || "v";
+      return {
+        type: VersioningType.Uri,
+        result: `${prefix}${version}`
+      };
+    },
+    [VersioningType.Header]: (version, versioning) => {
+      const headers = {
+        [versioning.header || "version"]: version
+      };
+      return {
+        type: VersioningType.Header,
+        result: headers
+      };
+    },
+    [VersioningType.Query]: (version, versioning) => {
+      const key = versioning.key || "v";
+      return {
+        type: VersioningType.Query,
+        result: {
+          [key]: version
+        }
+      };
+    },
+    [VersioningType.Custom]: (version, versioning) => {
+      return versioning.extractor({
+        version
       });
-      Reflect.defineMetadata(EVENT_SOURCE_EVENTS_KEY, events, target);
-    };
-  };
-  const EVENT_SOURCE_OPEN_KEY = Symbol("EVENT_SOURCE_OPEN_KEY");
-  const OnSseOpen = () => {
-    return (target, propertyKey) => {
-      Reflect.defineMetadata(EVENT_SOURCE_OPEN_KEY, target[propertyKey], target);
-    };
-  };
-  const EVENT_SOURCE_ERROR_KEY = Symbol("EVENT_SOURCE_ERROR_KEY");
-  const OnSseError = () => {
-    return (target, propertyKey) => {
-      Reflect.defineMetadata(EVENT_SOURCE_ERROR_KEY, target[propertyKey], target);
-    };
+    }
   };
-  class Snail {
-    constructor() {
-      __publicField(this, "axiosInstance");
-      // private config: SnailConfig;
+  function applyVersioning(version, versioning) {
+    if (!versioning) return void 0;
+    const handler = versionHandlers[versioning.type];
+    return handler(
+      version,
+      versioning
+    );
+  }
+  const UPLOAD_PROGRESS_KEY = Symbol("SNAIL_UPLOAD_PROGRESS_KEY");
+  const DOWNLOAD_PROGRESS_KEY = Symbol("SNAIL_DOWNLOAD_PROGRESS_KEY");
+  class SnailMethod {
+    constructor(apiInstance, target, propertyKey, args) {
+      // 私有属性
+      // private serverInstance: SnailServer;
+      __publicField(this, "Name");
+      __publicField(this, "apiInstance");
+      __publicField(this, "target");
       __publicField(this, "strategies", []);
-      __publicField(this, "cacheStorage");
-      __publicField(this, "version");
-      __publicField(this, "sourceMap", /* @__PURE__ */ new Map());
-      __publicField(this, "eventSource");
-    }
-    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
+      __publicField(this, "Request");
+      __publicField(this, "Response");
+      __publicField(this, "Error");
+      __publicField(this, "eventMap");
+      __publicField(this, "onceWrapperMap");
+      __publicField(this, "propertyKey");
+      __publicField(this, "Url", "");
+      __publicField(this, "Path", "");
+      __publicField(this, "Method", RequestMethodEnum.GET);
+      __publicField(this, "Version");
+      __publicField(this, "Args", []);
+      __publicField(this, "send", async () => {
+        this.enableLog() && console.log("send:", this.name);
+        const [serverName] = this.apiInstance.name.split(".");
+        const axios2 = AxiosInstanceMap.get(serverName);
+        if (!axios2) throw new Error("AxiosInstance not created");
+        const strategies = this.getStrategies();
+        this.Request = await applyStrategies(this.Request, strategies, "request");
+        this.Request = this.applyProgress(this.Request);
+        const { data, querys, params } = buildRequestArgs(
+          this.target,
+          this.propertyKey,
+          this.Args
+        );
+        console.log("apiurl:", this.apiInstance.url);
+        const newUrl = replacePlaceholders(this.Url, params);
+        this.Request = {
+          ...this.Request,
+          url: newUrl,
+          params: {
+            ...this.Request.params,
+            ...querys
+          },
+          data
+        };
+        this.enableLog() && console.log("request:", this.Request);
+        const isNoCache = this.isNoCache();
+        this.enableLog() && console.log("method is noCache:", isNoCache);
+        if (!isNoCache) {
+          const { data: data2 } = await this.getCacheData(serverName);
+          this.enableLog() && console.log("getCacheData:", data2);
+          if (data2) {
+            this.emit("hitCache", data2);
+            this.emit("success", data2);
+            this.emit("finish", data2);
+            return data2;
+          }
+        }
+        const requester = AxiosInstanceMap.get(serverName);
+        if (!requester) throw new Error("AxiosInstance not created");
+        try {
+          const rawResponse = await requester.request(this.Request);
+          const isSpecial = isSpecialResponse(rawResponse);
+          const response = await applyStrategies(
+            rawResponse,
+            strategies,
+            "response"
           );
-          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);
-              }
-            }
-            const onUploadProgress = Reflect.getMetadata(
-              UPLOAD_PROGRESS_KEY,
-              target,
-              propertyKey
-            );
-            const onDownloadProgress = Reflect.getMetadata(
-              DOWNLOAD_PROGRESS_KEY,
-              target,
-              propertyKey
-            );
-            try {
-              enableLog && console.log("send request:", request);
-              const response = await this.axiosInstance({
-                ...request,
-                onUploadProgress,
-                onDownloadProgress
-              });
-              const responseStrategies = strategies.filter(
-                (strategy) => strategy.applyResponse
-              );
-              const strategyResponse = await this.applyStrategies(
-                response,
-                responseStrategies,
-                "response"
-              );
-              hitSource !== null && this.setCache(request, response);
-              this.expireCache(propertyKey);
-              return this.handleResponse(strategyResponse, false);
-            } catch (error) {
-              return this.handleError(error);
-            }
-          };
+          if (!isNoCache) {
+            !isSpecial && await this.setCacheData(serverName, response);
+          }
+          this.Response = response;
+          this.applyHitSource(serverName);
+          this.emit("success", response.data);
+          this.emit("finish", response.data);
+          if (isSpecial) return response;
+          return response.data;
+        } catch (error) {
+          this.emit("error", error);
+          this.emit("finish", error);
+          console.error(error);
+          this.Error = error;
+          return error;
         }
       });
+      this.apiInstance = apiInstance;
+      this.target = target;
+      this.propertyKey = propertyKey.toString();
+      this.Args = args ?? [];
+      this.init();
+      console.log("url:", this.Url);
+      this.eventMap = /* @__PURE__ */ new Map();
+      this.onceWrapperMap = /* @__PURE__ */ new Map();
+      this.eventMap.set("success", /* @__PURE__ */ new Set());
+      this.eventMap.set("hitCache", /* @__PURE__ */ new Set());
+      this.eventMap.set("error", /* @__PURE__ */ new Set());
+      this.eventMap.set("finish", /* @__PURE__ */ new Set());
+    }
+    init() {
+      const methodOptions = this.getMethodOptions();
+      if (!methodOptions) {
+        throw new Error("Create SnailMethod must be used for decoration");
+      }
+      const { path, method, name } = methodOptions;
+      this.Name = name ?? this.propertyKey;
+      this.Path = path;
+      this.Method = method;
+      this.createRequest();
+      this.initUrl();
+      this.initVersion();
+    }
+    initUrl() {
+      const url = this.Path == "" ? this.apiInstance.url || "" : `${this.apiInstance.url || ""}${resolveUrl(this.Path)}`;
+      this.Url = url;
+    }
+    initVersion() {
+      const version = Reflect.getMetadata(
+        VERSION_KEY,
+        this.target,
+        this.propertyKey
+      );
+      this.Version = version ?? this.apiInstance.version;
+      if (!this.Version) return;
+      const [serverName] = this.apiInstance.name.split(".");
+      const versioningOptions = VersioningMap.get(serverName);
+      if (!versioningOptions) {
+        console.warn("Version Manager not configured");
+        console.log(
+          "Please use @Versioning() to configure the version manager on the ` SnailServer ` class"
+        );
+        return;
+      }
+      const versioningResult = applyVersioning(this.Version, versioningOptions);
+      if (!versioningResult) {
+        console.warn("Apply Versioning error");
+        return;
+      }
+      const { type, result } = versioningResult;
+      if (type === VersioningType.Uri) {
+        this.Url = `${resolveUrl(result)}${resolveUrl(this.Url)}`;
+      }
+      if (type === VersioningType.Header) {
+        this.Request.headers = {
+          ...this.Request.headers,
+          ...result
+        };
+      }
+      if (type === VersioningType.Query) {
+        this.Request.params = {
+          ...this.Request.params,
+          ...result
+        };
+      }
     }
-    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;
+    getExpireSources() {
+      const invalidSources = ExpireSourceMap.get(this.name) ?? /* @__PURE__ */ new Set();
+      if (invalidSources.size === 0) return [];
+      return Array.from(invalidSources);
+    }
+    createRequest() {
+      const request = {
+        url: this.Url,
+        method: this.Method,
+        timeout: this.apiInstance.timeout,
+        data: {},
+        params: {},
+        headers: {}
+      };
+      this.Request = request;
+      return request;
+    }
+    onSuccess(handler) {
+      this.on("success", handler);
+    }
+    onError(handler) {
+      this.on("error", handler);
+    }
+    onHitCache(handler) {
+      this.on("hitCache", handler);
+    }
+    onFinish(handler) {
+      this.on("finish", handler);
+    }
+    on(eventName, handler) {
+      if (typeof handler !== "function") {
+        throw new TypeError("Handler must be a function");
+      }
+      const handlers = this.eventMap.get(eventName) || /* @__PURE__ */ new Set();
+      handlers.add(handler);
+      this.eventMap.set(eventName, handlers);
+    }
+    once(eventName, handler) {
+      const onceHandler = (data) => {
+        try {
+          handler.apply(this, [data]);
+        } finally {
+          this.off(eventName, onceHandler);
+          this.onceWrapperMap.delete(handler);
         }
+      };
+      this.onceWrapperMap.set(handler, onceHandler);
+      this.on(eventName, onceHandler);
+    }
+    emit(eventName, ...args) {
+      const handlers = this.eventMap.get(eventName);
+      if (!handlers || handlers.size === 0) return false;
+      handlers.forEach((handler) => {
+        Promise.resolve().then(() => {
+          handler.apply(this, args);
+        });
       });
-      return requestArgs;
+      return true;
     }
-    getStrategies(target, propertyKey) {
-      const serverStrategies = Reflect.getMetadata(STRATEGY_KEY, this.constructor) || [];
-      const classStrategies = Reflect.getMetadata(STRATEGY_KEY, target.constructor) || [];
+    off(eventName, handler) {
+      const handlers = this.eventMap.get(eventName);
+      if (!handlers) return;
+      if (handlers.has(handler)) {
+        handlers.delete(handler);
+      }
+      if (handlers.size === 0) {
+        this.eventMap.delete(eventName);
+      }
+    }
+    async getCacheData(serverName) {
+      const methodKey = await generateCacheKey(
+        this.name,
+        this.version,
+        this.Request
+      );
+      const cacheStorage = CacheStorageMap.get(serverName);
+      if (!cacheStorage) {
+        throw new Error("CacheStorage not created");
+      }
+      const cacheData = await cacheStorage.get(methodKey);
+      const { error } = cacheData;
+      if (!error) {
+        this.enableLog() && console.warn(`[${this.Name}]`, "Cache hit");
+      }
+      return cacheData;
+    }
+    async setCacheData(serverName, responseData) {
+      const methodKey = await generateCacheKey(
+        this.name,
+        this.version,
+        this.Request
+      );
+      this.enableLog() && console.log("setCacheData:", methodKey);
+      const cacheStorage = CacheStorageMap.get(serverName);
+      if (!cacheStorage) throw new Error("CacheStorage not created");
+      const ttl = CacheTtlMap.get(serverName);
+      const cacheData = {
+        data: responseData.data,
+        exp: Date.now() + ttl * 1e3
+      };
+      cacheStorage.set(methodKey, cacheData);
+    }
+    get response() {
+      return this.Response;
+    }
+    get request() {
+      return this.Request;
+    }
+    get version() {
+      return this.Version;
+    }
+    get name() {
+      return `${this.apiInstance.name}.${this.Name}`;
+    }
+    get error() {
+      if (this.Error) return this.Error;
+      return null;
+    }
+    registerStrategies(...strategys) {
+      this.strategies.push(...strategys);
+    }
+    getStrategies() {
+      const [serverName, apiName] = this.apiInstance.name.split(".");
+      const serverStrategies = StrategyMap.get(serverName) ?? [];
+      const apiStrategies = StrategyMap.get(apiName) ?? [];
       const methodStrategies = Reflect.getMetadata(
-        `${STRATEGY_KEY.toString()}_${propertyKey}`,
-        target
+        `${STRATEGY_KEY.toString()}_${this.propertyKey}`,
+        this.target
       ) || [];
       const allStrategies = [
-        ...this.strategies,
         ...serverStrategies,
-        ...classStrategies,
+        ...apiStrategies,
         ...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));
+    getMethodOptions() {
+      const methodConfig = Reflect.getMetadata(
+        METHOD_KEY,
+        this.target,
+        this.propertyKey
+      );
+      return methodConfig;
+    }
+    isNoCache() {
+      const [serverName] = this.apiInstance.name.split(".");
+      const cacheForMap = CacheForMap.get(serverName);
+      let flag = false;
+      if (typeof cacheForMap === "string" && (cacheForMap.toLowerCase() === "all" || cacheForMap === this.Method)) {
+        flag = true;
+      }
+      if (Array.isArray(cacheForMap)) {
+        flag = cacheForMap.includes(this.Method);
+      }
+      const isMethodNoCache = Reflect.getMetadata(
+        NO_CACHE_KEY,
+        this.target,
+        this.propertyKey
+      );
+      const isApiNoCache = this.apiInstance.noCache;
+      const noCacheFlag = isMethodNoCache ? true : isApiNoCache ? true : false;
+      return flag ? noCacheFlag : true;
+    }
+    enableLog() {
+      return this.apiInstance.enableLog;
+    }
+    async applyHitSource(serverName) {
+      const sources = this.getExpireSources();
+      const cacheStorage = CacheStorageMap.get(serverName);
+      if (cacheStorage) {
+        const cacheKeys = await cacheStorage.keys();
+        sources.map((source) => {
+          cacheKeys.map((key) => {
+            if (key.startsWith(source)) {
+              this.enableLog() && console.warn(`[${this.name}]请求成功，触发清除缓存：${source}`);
+              cacheStorage.delete(key);
+            }
+          });
+        });
+      }
+    }
+    applyProgress(request) {
+      const onUploadProgress = Reflect.getMetadata(
+        UPLOAD_PROGRESS_KEY,
+        this.target,
+        this.propertyKey
+      );
+      const onDownloadProgress = Reflect.getMetadata(
+        DOWNLOAD_PROGRESS_KEY,
+        this.target,
+        this.propertyKey
+      );
+      return {
+        ...request,
+        onUploadProgress,
+        onDownloadProgress
+      };
+    }
+  }
+  const CacheStorageMap = /* @__PURE__ */ new Map();
+  const CacheTtlMap = /* @__PURE__ */ new Map();
+  const CacheForMap = /* @__PURE__ */ new Map();
+  const ExpireSourceMap = /* @__PURE__ */ new Map();
+  const AxiosInstanceMap = /* @__PURE__ */ new Map();
+  const StrategyMap = /* @__PURE__ */ new Map();
+  const VersioningMap = /* @__PURE__ */ new Map();
+  const defaultCacheManageOptions = {
+    type: CacheType.Memory,
+    ttl: 500
+  };
+  const defaultServerOptions = {
+    baseURL: "",
+    timeout: 5e3,
+    cacheManage: defaultCacheManageOptions,
+    cacheFor: "get",
+    enableLog: false
+  };
+  class SnailServer {
+    constructor() {
+      __publicField(this, "Name");
+      __publicField(this, "BaseURL");
+      __publicField(this, "Version");
+      __publicField(this, "EnableLog", false);
+      const options = this.getServerOptions();
+      this.Name = options.name ?? this.constructor.name;
+      this.init();
+    }
+    init() {
+      const options = this.getServerOptions();
+      const { baseURL, timeout, cacheManage, enableLog, cacheFor } = options;
+      this.BaseURL = baseURL ?? resolveUrl("");
+      this.initAxios({ baseURL, timeout });
+      this.initStrategy();
+      this.initCacheManage(cacheManage, cacheFor);
+      this.initVersioning();
+      this.initExpireSource(this);
+      this.EnableLog = enableLog ?? false;
+      this.initLog(enableLog);
+    }
+    initLog(enableLog) {
+      if (enableLog) {
+        const axiosInstance = AxiosInstanceMap.get(this.Name);
+        axiosInstance.interceptors.request.use((config) => {
+          console.log("Request:", config);
+          return config;
+        });
+        axiosInstance.interceptors.response.use((response) => {
+          console.log("Response:", response);
+          return response;
+        });
+      }
+    }
+    initStrategy() {
+      const serverStrategies = Reflect.getMetadata(STRATEGY_KEY, this.constructor) || [];
+      StrategyMap.set(this.Name, serverStrategies);
     }
-    applyVersion(request, target, propertyKey) {
+    initVersioning() {
       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() }
-        };
-        return cacheResponse;
+      if (versioning) {
+        VersioningMap.set(this.Name, versioning);
       }
-      return void 0;
     }
-    initCacheManage(options) {
-      if (!this.cacheStorage && options !== void 0) {
-        this.cacheStorage = createCache(options.type, options.ttl || 300);
-      }
+    registerStrategies(...strategys) {
+      const serverStrategies = StrategyMap.get(this.Name) ?? [];
+      serverStrategies.push(...strategys);
+      StrategyMap.set(this.Name, serverStrategies);
     }
-    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
+    createApi(constructor) {
+      const serverVersioning = Reflect.getMetadata(
+        VERSIONING_KEY,
+        this.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]);
-      }
-    }
-    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));
-          })
-        );
+      if (serverVersioning) {
+        this.Version = serverVersioning.defaultVersion || "";
       }
+      const apiInstanceOptions = {
+        serverInstance: this,
+        enableLog: this.EnableLog
+      };
+      const apiInstance = new constructor(apiInstanceOptions);
+      this.initExpireSource(apiInstance);
+      return new Proxy(apiInstance, {
+        get: (target, propertyKey) => {
+          if (typeof propertyKey !== "string")
+            return target[propertyKey];
+          const methodConfig = Reflect.getMetadata(
+            METHOD_KEY,
+            target,
+            propertyKey
+          );
+          if (!methodConfig) return target[propertyKey];
+          return (...args) => {
+            const method = new SnailMethod(apiInstance, target, propertyKey, [
+              ...args
+            ]);
+            this.initExpireSource(method, propertyKey);
+            return method;
+          };
+        }
+      });
     }
-    getServerConfig() {
-      return Reflect.getMetadata(
-        SERVER_CONFIG_KEY,
+    initCacheManage(options, cacheFor) {
+      const noCache = Reflect.getMetadata(
+        NO_CACHE_KEY,
         this.constructor
       );
+      if (noCache && options !== defaultCacheManageOptions) {
+        console.warn("you configured cache manage, but you set noCache");
+        return;
+      }
+      const cacheStorage = CacheStorageMap.get(this.Name);
+      if (!cacheStorage && options !== void 0) {
+        const storage = createCache(options);
+        CacheStorageMap.set(this.Name, storage);
+        CacheTtlMap.set(this.Name, options.ttl || 500);
+      }
+      if (cacheFor) {
+        CacheForMap.set(this.Name, cacheFor);
+      }
     }
-    getApiConfig(constructor) {
-      return Reflect.getMetadata(API_CONFIG_KEY, constructor);
+    initExpireSource(target, propertyKey) {
+      if (propertyKey) {
+        const expireSource = Reflect.getMetadata(
+          CACHE_EXPIRE_SOURCE_KEY,
+          target.target,
+          propertyKey
+        );
+        if (expireSource && expireSource.length > 0) {
+          expireSource.map((source) => {
+            const invalidSources = ExpireSourceMap.get(source) ?? /* @__PURE__ */ new Set();
+            invalidSources.add(target.name);
+            ExpireSourceMap.set(source, invalidSources);
+          });
+        }
+        return;
+      }
+      const expireSources = Reflect.getMetadata(
+        CACHE_EXPIRE_SOURCE_KEY,
+        target.constructor
+      ) ?? [];
+      if (expireSources.length > 0) {
+        expireSources.map((source) => {
+          const invalidSources = ExpireSourceMap.get(source) ?? /* @__PURE__ */ new Set();
+          invalidSources.add(target.name);
+          ExpireSourceMap.set(source, invalidSources);
+        });
+      }
     }
     initAxios(config) {
-      if (!this.axiosInstance) {
-        this.axiosInstance = axios.create({
-          baseURL: config.baseURL,
+      const axiosInstance = AxiosInstanceMap.get(this.Name);
+      if (!axiosInstance) {
+        const axiosInstance2 = axios.create({
+          baseURL: resolveUrl(config.baseURL),
           timeout: config.timeout
         });
+        AxiosInstanceMap.set(this.Name, axiosInstance2);
       }
     }
-    generateSseUrl(baseURL, url) {
-      if (!baseURL && !url) {
-        return "/";
-      }
-      if (!baseURL && url) {
-        return `/${url}`;
+    getServerOptions() {
+      const serverOptions = Reflect.getMetadata(
+        SERVER_CONFIG_KEY,
+        this.constructor
+      );
+      if (!serverOptions) {
+        throw new Error(
+          "Create SnailServer must be used for @Server() decoration"
+        );
       }
-      return `${baseURL}/${url}`;
+      const options = Object.assign({}, defaultServerOptions, serverOptions);
+      return options;
     }
-    handleResponse(response, hitCache) {
-      return {
-        data: response.data,
-        error: null,
-        hitCache
-      };
+    createSse(constructor) {
+      const sseInstance = new constructor(this);
+      return sseInstance;
     }
-    handleError(error) {
-      return {
-        data: null,
-        error
-      };
+    get version() {
+      return this.Version;
     }
-    createSse(constructor) {
-      const instance = new constructor();
-      const serverConfig = this.getServerConfig();
-      const { baseURL, enableLog } = serverConfig;
-      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 sseOption = Reflect.getMetadata(
-            EVENT_SOURCE_OPTION_KEY,
-            target,
-            propertyKey
-          );
-          if (sseOption) {
-            const url = sseOption.path == "" ? apiConfig.url : apiConfig.url + `/${sseOption.path}`;
-            const { url: versionUrl } = this.applyVersion(
-              { url },
-              target,
-              propertyKey
-            );
-            const sseUrl = this.generateSseUrl(baseURL, versionUrl || url);
-            enableLog && console.log("sse-url:", sseUrl);
-            return () => this.initSse(sseUrl, sseOption, target);
-          }
-        }
-      });
+    get name() {
+      return this.Name;
     }
-    initSse(url, options, target) {
-      return () => {
-        const eventSource = new EventSource(url, {
-          withCredentials: options.withCredentials ? options.withCredentials : false
-        });
-        this.eventSource = eventSource;
-        this.setSse(target);
-        this.registerSseEvent(target);
-        return {
-          eventSource,
-          close: eventSource.close
-        };
-      };
+    get enableLog() {
+      return this.EnableLog;
     }
-    setSse(target) {
-      const onOpenFunc = Reflect.getMetadata(EVENT_SOURCE_OPEN_KEY, target);
-      if (typeof onOpenFunc == "function") {
-        this.eventSource && (this.eventSource.onopen = onOpenFunc);
+    get baseUrl() {
+      return this.BaseURL;
+    }
+  }
+  class SnailApi {
+    constructor(options) {
+      __publicField(this, "Name");
+      __publicField(this, "serverInstance");
+      __publicField(this, "Version");
+      __publicField(this, "Url");
+      __publicField(this, "Timeout");
+      __publicField(this, "EnableLog");
+      const apiConfig = this.getApiConfig();
+      if (!apiConfig) {
+        throw new Error("Create SnailApi must be used for @Api() decoration");
+      }
+      const { serverInstance, enableLog } = options;
+      this.serverInstance = serverInstance;
+      this.EnableLog = enableLog ? true : false;
+      this.init();
+    }
+    init() {
+      const apiConfig = this.getApiConfig();
+      this.initName();
+      this.initStrategy();
+      this.Version = apiConfig.version ?? this.serverInstance.version;
+      this.Url = apiConfig.url;
+      this.Timeout = apiConfig.timeout;
+    }
+    initStrategy() {
+      const serverStrategies = Reflect.getMetadata(STRATEGY_KEY, this.constructor) || [];
+      StrategyMap.set(this.Name, serverStrategies);
+    }
+    registerStrategies(...strategys) {
+      const serverStrategies = StrategyMap.get(this.Name) ?? [];
+      serverStrategies.push(...strategys);
+      StrategyMap.set(this.Name, serverStrategies);
+    }
+    initName() {
+      const { name } = this.getApiConfig();
+      const apiName = name ?? this.constructor.name;
+      this.Name = `${this.serverInstance.name}.${apiName}`;
+    }
+    getApiConfig() {
+      return Reflect.getMetadata(
+        API_CONFIG_KEY,
+        this.constructor
+      );
+    }
+    isNoCache() {
+      const isServerNoCache = Reflect.getMetadata(
+        NO_CACHE_KEY,
+        this.serverInstance.constructor
+      );
+      const isApiNoCache = Reflect.getMetadata(
+        NO_CACHE_KEY,
+        this.constructor
+      );
+      return isServerNoCache || isApiNoCache;
+    }
+    get version() {
+      return this.Version;
+    }
+    get url() {
+      return this.Url;
+    }
+    get name() {
+      return this.Name;
+    }
+    get noCache() {
+      return this.isNoCache();
+    }
+    get enableLog() {
+      return this.EnableLog;
+    }
+    get timeout() {
+      return this.Timeout;
+    }
+  }
+  const EVENT_SOURCE_OPTION_KEY = Symbol("SNAIL_EVENT_SOURCE_OPTION_KEY");
+  const Sse = (path, options) => {
+    return (target) => {
+      Reflect.defineMetadata(
+        EVENT_SOURCE_OPTION_KEY,
+        {
+          path,
+          ...options
+        },
+        target
+      );
+    };
+  };
+  const EVENT_SOURCE_EVENTS_KEY = Symbol("EVENT_SOURCE_EVENTS_KEY");
+  const SseEvent = (eventName, options) => {
+    return (target, propertyKey) => {
+      const events = Reflect.getMetadata(EVENT_SOURCE_EVENTS_KEY, target) || [];
+      events.push({
+        eventName: eventName ? eventName : "message",
+        emit: target[propertyKey],
+        options
+      });
+      Reflect.defineMetadata(EVENT_SOURCE_EVENTS_KEY, events, target);
+    };
+  };
+  const EVENT_SOURCE_OPEN_KEY = Symbol("EVENT_SOURCE_OPEN_KEY");
+  const OnSseOpen = () => {
+    return (target, propertyKey) => {
+      Reflect.defineMetadata(EVENT_SOURCE_OPEN_KEY, target[propertyKey], target);
+    };
+  };
+  const EVENT_SOURCE_ERROR_KEY = Symbol("EVENT_SOURCE_ERROR_KEY");
+  const OnSseError = () => {
+    return (target, propertyKey) => {
+      Reflect.defineMetadata(EVENT_SOURCE_ERROR_KEY, target[propertyKey], target);
+    };
+  };
+  const defaultSseOptions = {
+    path: "",
+    withCredentials: false
+  };
+  class SnailSse {
+    constructor(server) {
+      __publicField(this, "_serverInstance");
+      __publicField(this, "_baseUrl");
+      __publicField(this, "_url");
+      __publicField(this, "_version");
+      __publicField(this, "_withCredentials");
+      __publicField(this, "_eventSource");
+      this._serverInstance = server;
+      this._baseUrl = server.baseUrl;
+      const options = this.getSseOptions();
+      const { path, withCredentials, version } = options;
+      this._url = resolveUrl(path);
+      this._version = version;
+      this._withCredentials = withCredentials ? withCredentials : false;
+      this.initVersion();
+    }
+    getSseOptions() {
+      const sseOptions = Reflect.getMetadata(
+        EVENT_SOURCE_OPTION_KEY,
+        this.constructor
+      );
+      if (!sseOptions) {
+        throw new Error(
+          "you need to use @Sse() decorator to decorate your class"
+        );
       }
-      const onErrorFunc = Reflect.getMetadata(EVENT_SOURCE_ERROR_KEY, target);
-      if (typeof onErrorFunc == "function") {
-        this.eventSource && (this.eventSource.onerror = onErrorFunc);
+      const options = Object.assign({}, defaultSseOptions, sseOptions);
+      return options;
+    }
+    initVersion() {
+      const versioningOptions = VersioningMap.get(this._serverInstance.name);
+      if (!versioningOptions || !this._version) return;
+      const versioningResult = applyVersioning(this._version, versioningOptions);
+      if (!versioningResult) return;
+      const { type, result } = versioningResult;
+      if (type === VersioningType.Uri) {
+        const url = `${resolveUrl(result)}${this._url}`;
+        this._url = url;
+        return;
+      }
+      if (type === VersioningType.Query) {
+        const k = Object.keys(result)[0];
+        const v = result[k];
+        this._url = `resolveUrl(${this._url}?${k}=${v})`;
+        return;
       }
     }
-    registerSseEvent(target) {
+    open() {
+      const url = `${this._baseUrl}${this._url}`;
+      const eventSource = new EventSource(url, {
+        withCredentials: this._withCredentials
+      });
+      this._eventSource = eventSource;
+      this.setEvent();
+      this.registerSseEvent();
+    }
+    close() {
       const eventSource = this.eventSource;
       if (!eventSource) return;
+      eventSource.close();
+    }
+    registerSseEvent() {
+      const eventSource = this._eventSource;
+      if (!eventSource) return;
       const events = Reflect.getMetadata(
         EVENT_SOURCE_EVENTS_KEY,
-        target
+        this.constructor
       );
       events.map((event) => {
         eventSource.addEventListener(event.eventName, event.emit, event.options);
       });
     }
+    setEvent() {
+      const onOpenFunc = Reflect.getMetadata(
+        EVENT_SOURCE_OPEN_KEY,
+        this.constructor
+      );
+      if (typeof onOpenFunc == "function") {
+        this._eventSource && (this._eventSource.onopen = onOpenFunc);
+      }
+      const onErrorFunc = Reflect.getMetadata(
+        EVENT_SOURCE_ERROR_KEY,
+        this.constructor
+      );
+      if (typeof onErrorFunc == "function") {
+        this._eventSource && (this._eventSource.onerror = onErrorFunc);
+      }
+    }
+    on(eventName, callback, options) {
+      this._eventSource && this._eventSource.addEventListener(eventName, callback, options);
+    }
+    off(eventName, callback, options) {
+      this._eventSource && this._eventSource.removeEventListener(eventName, callback, options);
+    }
+    get url() {
+      return this._url;
+    }
+    get eventSource() {
+      return this._eventSource;
+    }
   }
   exports2.Api = Api;
-  exports2.Cache = Cache;
+  exports2.CacheStorageAdapter = CacheStorageAdapter;
   exports2.CacheType = CacheType;
   exports2.Data = Data;
   exports2.Delete = Delete;
+  exports2.EventType = EventType;
   exports2.Get = Get;
   exports2.Head = Head;
+  exports2.HitSource = HitSource;
+  exports2.NoCache = NoCache;
   exports2.OnSseError = OnSseError;
   exports2.OnSseOpen = OnSseOpen;
   exports2.Options = Options;
@@ -4210,19 +4793,30 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
   exports2.Patch = Patch;
   exports2.Post = Post;
   exports2.Put = Put;
-  exports2.RegisterSseEvent = RegisterSseEvent;
-  exports2.RequestMethod = RequestMethod;
+  exports2.Query = Query;
+  exports2.RequestMethodEnum = RequestMethodEnum;
   exports2.Server = Server;
-  exports2.Snail = Snail;
+  exports2.SnailApi = SnailApi;
+  exports2.SnailMethod = SnailMethod;
+  exports2.SnailPass = SnailPass;
+  exports2.SnailServer = SnailServer;
+  exports2.SnailSse = SnailSse;
   exports2.Sse = Sse;
   exports2.SseEvent = SseEvent;
+  exports2.SseEventListener = SseEventListener;
+  exports2.SseOptions = SseOptions;
   exports2.Strategy = Strategy;
   exports2.UseStrategy = UseStrategy;
   exports2.Version = Version;
   exports2.Versioning = Versioning;
   exports2.VersioningType = VersioningType;
-  exports2.apiKey = apiKey;
+  exports2.applyStrategies = applyStrategies;
+  exports2.buildRequestArgs = buildRequestArgs;
+  exports2.generateCacheKey = generateCacheKey;
   exports2.generateShortUniqueHash = generateShortUniqueHash;
+  exports2.isSpecialResponse = isSpecialResponse;
   exports2.recordToString = recordToString;
+  exports2.replacePlaceholders = replacePlaceholders;
+  exports2.resolveUrl = resolveUrl;
   Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
 });