@snail-js/api 0.1.14 → 0.1.16

package/dist/snail-api.js

@@ -1461,7 +1461,7 @@ const utils$1 = {
   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);
@@ -1478,7 +1478,7 @@ function AxiosError$1(message, code, config, request, response) {
     this.status = response.status ? response.status : null;
   }
 }
-utils$1.inherits(AxiosError$1, Error, {
+utils$1.inherits(AxiosError, Error, {
   toJSON: function toJSON() {
     return {
       // Standard
@@ -1499,7 +1499,7 @@ utils$1.inherits(AxiosError$1, Error, {
     };
   }
 });
-const prototype$1 = AxiosError$1.prototype;
+const prototype$1 = AxiosError.prototype;
 const descriptors = {};
 [
   "ERR_BAD_OPTION_VALUE",
@@ -1518,16 +1518,16 @@ const descriptors = {};
 ].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 filter2(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);
@@ -1553,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$1(obj, formData, options) {
+function toFormData(obj, formData, options) {
   if (!utils$1.isObject(obj)) {
     throw new TypeError("target must be an object");
   }
@@ -1580,7 +1580,7 @@ function toFormData$1(obj, formData, options) {
       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);
@@ -1659,7 +1659,7 @@ function encode$1(str) {
 }
 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) {
@@ -1801,7 +1801,7 @@ const platform = {
   ...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"));
@@ -1905,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$1(
+        return toFormData(
           isFileList2 ? { "files[]": data } : data,
           _FormData && new _FormData(),
           this.formSerializer
@@ -1933,7 +1933,7 @@ const defaults = {
       } 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;
         }
@@ -2061,7 +2061,7 @@ function buildAccessors(obj, header) {
     });
   });
 }
-let AxiosHeaders$1 = class AxiosHeaders {
+class AxiosHeaders {
   constructor(headers) {
     headers && this.set(headers);
   }
@@ -2216,9 +2216,9 @@ let AxiosHeaders$1 = class AxiosHeaders {
     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,
@@ -2227,11 +2227,11 @@ utils$1.reduceDescriptors(AxiosHeaders$1.prototype, ({ value }, key) => {
     }
   };
 });
-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);
@@ -2239,14 +2239,14 @@ function transformData(fns, response) {
   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) {
@@ -2254,9 +2254,9 @@ function settle(resolve, reject, response) {
   if (!response.status || !validateStatus2 || validateStatus2(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
@@ -2415,8 +2415,8 @@ function buildFullPath(baseURL, requestedURL) {
   }
   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) {
@@ -2494,9 +2494,9 @@ function mergeConfig$1(config1, config2) {
   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(
@@ -2529,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$1.from(_config.headers).normalize();
+    const requestHeaders = AxiosHeaders.from(_config.headers).normalize();
     let { responseType, onUploadProgress, onDownloadProgress } = _config;
     let onCanceled;
     let uploadThrottled, downloadThrottled;
@@ -2547,7 +2547,7 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
       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;
@@ -2585,11 +2585,11 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
       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() {
@@ -2598,9 +2598,9 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
       if (_config.timeoutErrorMessage) {
         timeoutErrorMessage = _config.timeoutErrorMessage;
       }
-      reject(new AxiosError$1(
+      reject(new AxiosError(
         timeoutErrorMessage,
-        transitional2.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED,
+        transitional2.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,
         config,
         request
       ));
@@ -2632,7 +2632,7 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
         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;
       };
@@ -2643,7 +2643,7 @@ const xhrAdapter = isXHRAdapterSupported && function(config) {
     }
     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);
@@ -2659,12 +2659,12 @@ const composeSignals = (signals, timeout) => {
         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) {
@@ -2787,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$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());
@@ -2899,7 +2899,7 @@ const fetchAdapter = isFetchSupported && (async (config) => {
     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,
@@ -2910,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$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 = {
@@ -2949,7 +2949,7 @@ const adapters = {
       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) {
@@ -2962,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$1(
+      throw new AxiosError(
         `There is no suitable adapter to dispatch the request ` + s,
         "ERR_NOT_SUPPORT"
       );
@@ -2976,12 +2976,12 @@ function throwIfCancellationRequested(config) {
     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
@@ -2997,10 +2997,10 @@ function dispatchRequest(config) {
       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(
@@ -3008,13 +3008,13 @@ function dispatchRequest(config) {
           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) {
@@ -3024,13 +3024,13 @@ const validators$1 = {};
 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]) {
@@ -3053,7 +3053,7 @@ validators$1.spelling = function spelling(correctSpelling) {
 };
 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;
@@ -3064,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$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);
     }
   }
 }
@@ -3078,7 +3078,7 @@ const validator = {
   validators: validators$1
 };
 const validators = validator.validators;
-let Axios$1 = class Axios {
+class Axios {
   constructor(instanceConfig) {
     this.defaults = instanceConfig;
     this.interceptors = {
@@ -3121,7 +3121,7 @@ let Axios$1 = class Axios {
     } else {
       config = configOrUrl || {};
     }
-    config = mergeConfig$1(this.defaults, config);
+    config = mergeConfig(this.defaults, config);
     const { transitional: transitional2, paramsSerializer, headers } = config;
     if (transitional2 !== void 0) {
       validator.assertOptions(transitional2, {
@@ -3157,7 +3157,7 @@ let Axios$1 = class Axios {
         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) {
@@ -3211,14 +3211,14 @@ let Axios$1 = class Axios {
     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
@@ -3228,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$1(config || {}, {
+      return this.request(mergeConfig(config || {}, {
         method,
         headers: isForm ? {
           "Content-Type": "multipart/form-data"
@@ -3238,10 +3238,10 @@ utils$1.forEach(["post", "put", "patch"], function forEachMethodWithData(method)
       }));
     };
   }
-  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 CancelToken {
+class CancelToken {
   constructor(executor) {
     if (typeof executor !== "function") {
       throw new TypeError("executor must be a function.");
@@ -3274,7 +3274,7 @@ let CancelToken$1 = class CancelToken {
       if (token.reason) {
         return;
       }
-      token.reason = new CanceledError$1(message, config, request);
+      token.reason = new CanceledError(message, config, request);
       resolvePromise(token.reason);
     });
   }
@@ -3335,16 +3335,16 @@ let CancelToken$1 = class CancelToken {
       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,
@@ -3409,102 +3409,115 @@ const HttpStatusCode$1 = {
   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 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: 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", {});
+    // 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);
       }
     });
   }
@@ -3519,12 +3532,18 @@ class LocalStorageCache {
       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) {
@@ -3542,8 +3561,9 @@ class LocalStorageCache {
             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 });
       }
     });
@@ -3552,12 +3572,34 @@ class LocalStorageCache {
     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;
@@ -3627,13 +3669,11 @@ class IndexDBCache {
         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);
       };
     });
   }
@@ -3644,27 +3684,49 @@ class IndexDBCache {
       }
       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";
@@ -3676,36 +3738,70 @@ var CacheType = /* @__PURE__ */ ((CacheType2) => {
   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 = async (apiInstance) => {
-  const { version, method, url, params, headers } = apiInstance;
-  const str = `${params ? `-${recordToString(params)}` : ""}${headers ? `-${recordToString(headers)}` : ""}`;
-  return `[${method}]${version ? `-v${version}` : ""}-${url}-${await 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);
@@ -3720,42 +3816,73 @@ function recordToString(record) {
     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) => {
@@ -3764,23 +3891,34 @@ const Api = (url = "", config) => {
   };
 };
 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) => {
@@ -3794,16 +3932,6 @@ const UseStrategy = (...strategies) => {
     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) => {
@@ -3816,390 +3944,845 @@ const Version = (version) => {
     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") {
-            await 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 = await 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() }
-      };
-      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;
-  }
-  async setHitSource(request, hitSource) {
-    const cacheKeys = this.sourceMap.get(hitSource);
-    const currentCacheKey = await 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 = await 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;
+  }
 }
 export {
   Api,
-  Cache,
+  CacheStorageAdapter,
   CacheType,
   Data,
   Delete,
+  EventType,
   Get,
   Head,
+  HitSource,
+  NoCache,
   OnSseError,
   OnSseOpen,
   Options,
@@ -4207,18 +4790,29 @@ export {
   Patch,
   Post,
   Put,
-  RegisterSseEvent,
-  RequestMethod,
+  Query,
+  RequestMethodEnum,
   Server,
-  Snail,
+  SnailApi,
+  SnailMethod,
+  SnailPass,
+  SnailServer,
+  SnailSse,
   Sse,
   SseEvent,
+  SseEventListener,
+  SseOptions,
   Strategy,
   UseStrategy,
   Version,
   Versioning,
   VersioningType,
-  apiKey,
+  applyStrategies,
+  buildRequestArgs,
+  generateCacheKey,
   generateShortUniqueHash,
-  recordToString
+  isSpecialResponse,
+  recordToString,
+  replacePlaceholders,
+  resolveUrl
 };