k99 0.2.0 → 0.3.0-beta.1

package/dist/k99.browser.js

@@ -0,0 +1,3110 @@
+/*!
+ * k99 v0.3.0-beta.1
+ * (c) 2019-2022 Fierflame
+ * @license MIT
+ */
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.k99 = {}));
+}(this, (function (exports) { 'use strict';
+
+	/**
+	 * 服务
+	 */
+	class Service {
+	  /**
+	   * @warning 不要重载构造函数或者主动调用创建实例
+	   */
+	  constructor(context) {
+	    this.context = context;
+	    Object.defineProperties(this, Object.getOwnPropertyDescriptors(context));
+	  }
+
+	  /** 销毁时，会自动调用此方法销毁自动创建的容器 */
+	  async destroy() {}
+
+	}
+
+	(function (_Service) {})(Service || (Service = {}));
+
+	var Service$1 = Service;
+
+	const returnSymbol = Symbol('return');
+	const catchSymbol = Symbol('catch');
+	const finallySymbol = Symbol('finally');
+	const dataSymbol = Symbol('data');
+	const initSymbol = Symbol('init');
+	const methodsSymbol = Symbol('methods');
+	const testSymbol = Symbol('test');
+	const optionsSymbol = Symbol('options');
+
+	function Handle(handle) {
+	  return handle;
+	}
+	/** 处理函数定义 */
+
+	exports.Log = void 0;
+
+	(function (_Log) {})(exports.Log || (exports.Log = {}));
+
+	exports.Settings = void 0;
+
+	(function (_Settings) {})(exports.Settings || (exports.Settings = {}));
+
+	exports.Assets = void 0;
+
+	(function (_Assets) {})(exports.Assets || (exports.Assets = {}));
+
+	function _defineProperty(obj, key, value) {
+	  if (key in obj) {
+	    Object.defineProperty(obj, key, {
+	      value: value,
+	      enumerable: true,
+	      configurable: true,
+	      writable: true
+	    });
+	  } else {
+	    obj[key] = value;
+	  }
+
+	  return obj;
+	}
+
+	/** 花括号开 */
+	const OPEN = '{';
+	/** 花括号关 */
+
+	const CLOSE = '}';
+	/** 正则匹配 */
+
+	const PATTERN = 3;
+	/** 名字 */
+
+	const NAME = 4;
+	/** 普通字符 */
+
+	const CHAR = 5;
+	/** 转义字符 */
+
+	const ESCAPED_CHAR = 6;
+	/** 数量修饰符 */
+
+	const MODIFIER = 7;
+
+	function getType$1(char) {
+	  if (char === '{') {
+	    return OPEN;
+	  }
+
+	  if (char === '}') {
+	    return CLOSE;
+	  }
+
+	  if (char === '*' || char === '+' || char === '?') {
+	    return MODIFIER;
+	  }
+
+	  return CHAR;
+	}
+
+	function isNameChar(c) {
+	  return '0' <= c && c <= '9' || 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c === '_';
+	}
+
+	function* lexer(str) {
+	  let i = 0;
+
+	  while (i < str.length) {
+	    const index = i;
+	    const char = str[i++];
+
+	    if (char === '\\') {
+	      const ch = str[i++];
+	      yield [ESCAPED_CHAR, index, ch];
+	      continue;
+	    }
+
+	    if (char === ':') {
+	      for (; i < str.length; i++) {
+	        if (!isNameChar(str[i])) {
+	          break;
+	        }
+	      }
+
+	      if (index + 1 === i) {
+	        yield [CHAR, i, char];
+	        continue;
+	      }
+
+	      yield [NAME, index, str.substring(index + 1, i)];
+	      continue;
+	    }
+
+	    if (char !== '(') {
+	      yield [getType$1(char), index, char];
+	      continue;
+	    }
+
+	    if (str[i] === '?') {
+	      throw new TypeError(`Pattern cannot start with "?" at ${i}`);
+	    }
+
+	    let count = 1;
+	    const pattern = ['(?:'];
+
+	    while (i < str.length) {
+	      const c = str[i++];
+	      pattern.push(c);
+
+	      if (c === '\\') {
+	        pattern.push(str[i++]);
+	        continue;
+	      }
+
+	      if (c === ')') {
+	        count--;
+
+	        if (count === 0) {
+	          break;
+	        }
+
+	        continue;
+	      }
+
+	      if (c === '[') {
+	        while (i < str.length) {
+	          const c = str[i++];
+	          pattern.push(c);
+
+	          if (c === ']') {
+	            break;
+	          }
+
+	          if (c !== '\\') {
+	            continue;
+	          }
+
+	          pattern.push(str[i++]);
+	        }
+
+	        continue;
+	      }
+
+	      if (c !== '(') {
+	        continue;
+	      }
+
+	      count++;
+	      pattern.push('?:');
+
+	      if (str[i] !== '?') {
+	        continue;
+	      }
+
+	      i += 2;
+
+	      if (str[i - 1] === ':') {
+	        continue;
+	      }
+
+	      throw new TypeError(`Invalid pattern group at ${i - 2}`);
+	    }
+
+	    if (count) {
+	      throw new TypeError(`Unterminated pattern at ${index}`);
+	    }
+
+	    if (!pattern.length) {
+	      throw new TypeError(`Missing pattern at ${index}`);
+	    }
+
+	    yield [PATTERN, index, pattern.join('')];
+	  }
+	}
+
+	function throwError([type, index, value]) {
+	  switch (type) {
+	    case OPEN:
+	    case CLOSE:
+	      throw new TypeError(`Unexpected token '${type}' at ${index}`);
+
+	    case PATTERN:
+	      throw new TypeError(`Unexpected pattern '(${value})' at ${index}`);
+
+	    case NAME:
+	      throw new TypeError(`Unexpected name ':${value}' at ${index}`);
+
+	    case CHAR:
+	      throw new TypeError(`Unexpected char '${value}' at ${index}`);
+
+	    case ESCAPED_CHAR:
+	      throw new TypeError(`Unexpected char '\\' at ${index}`);
+
+	    case MODIFIER:
+	      throw new TypeError(`Unexpected token '${value}' at ${index}`);
+	  }
+	}
+
+	const prefixes = '-/.:';
+
+	function throwUnexpectedError() {
+	  throw new TypeError('Unexpected end of input');
+	}
+
+	function* parse(tokens) {
+	  let i = 0;
+
+	  function get(type) {
+	    const token = tokens[i];
+
+	    if (!token) {
+	      return undefined;
+	    }
+
+	    const [nextType,, value] = token;
+
+	    if (nextType !== type) {
+	      return undefined;
+	    }
+
+	    i++;
+	    return value;
+	  }
+
+	  function getText() {
+	    let result = '';
+
+	    for (let token = tokens[i]; token; token = tokens[++i]) {
+	      const [type,, value] = token;
+
+	      if (CHAR === type) {
+	        result += value;
+	      } else if (ESCAPED_CHAR === type) {
+	        result += value;
+	      } else {
+	        break;
+	      }
+	    }
+
+	    return result;
+	  }
+
+	  const path = [];
+
+	  while (i < tokens.length) {
+	    const char = get(CHAR) || get(MODIFIER) || '';
+	    const name = get(NAME);
+	    const pattern = get(PATTERN);
+
+	    if (name || pattern) {
+	      let prefix = '';
+
+	      if (char && prefixes.includes(char)) {
+	        prefix = char;
+	      } else if (char) {
+	        path.push(char);
+	      }
+
+	      if (path.length) {
+	        yield path.join('');
+	        path.length = 0;
+	      }
+
+	      const modifier = get(MODIFIER) || '';
+	      yield {
+	        prefix,
+	        name: name || '',
+	        suffix: '',
+	        pattern,
+	        modifier
+	      };
+	      continue;
+	    }
+
+	    const value = char || get(ESCAPED_CHAR) || get(MODIFIER);
+
+	    if (value) {
+	      if (value !== '/') {
+	        path.push(value);
+	        continue;
+	      }
+
+	      if (path.length) {
+	        yield path.join('');
+	        path.length = 0;
+	      }
+
+	      yield '/';
+	      continue;
+	    }
+
+	    if (path.length) {
+	      yield path.join('');
+	      path.length = 0;
+	    }
+
+	    const openToken = tokens[i++];
+
+	    if (!openToken) {
+	      break;
+	    }
+
+	    if (openToken[0] !== OPEN) {
+	      throwError(openToken);
+	    }
+
+	    const prefix = getText();
+	    const groupName = get(NAME) || '';
+	    const groupPattern = get(PATTERN);
+	    const suffix = getText();
+	    const closeToken = tokens[i++];
+
+	    if (!closeToken) {
+	      throwUnexpectedError();
+	    }
+
+	    if (closeToken[0] !== CLOSE) {
+	      throwError(closeToken);
+	    }
+
+	    const modifier = get(MODIFIER) || '';
+	    yield {
+	      prefix,
+	      name: groupName || '',
+	      pattern: groupPattern,
+	      suffix,
+	      modifier,
+	      group: true
+	    };
+	  }
+
+	  if (path.length) {
+	    yield path.join('');
+	  }
+	}
+
+	function isNewLine(token) {
+	  if (token === '/') {
+	    return true;
+	  }
+
+	  if (typeof token !== 'string' && token.prefix === '/') {
+	    return true;
+	  }
+
+	  return false;
+	}
+
+	const dotRegex$1 = /^\.+$/;
+
+	function valid(paragraph) {
+	  if (paragraph[0] !== '/') {
+	    return true;
+	  }
+
+	  if (paragraph.length === 1) {
+	    return false;
+	  }
+
+	  if (paragraph.length !== 2) {
+	    return true;
+	  }
+
+	  const [, t] = paragraph;
+
+	  if (typeof t !== 'string') {
+	    return true;
+	  }
+
+	  if (!dotRegex$1.test(t)) {
+	    return true;
+	  }
+
+	  return false;
+	}
+
+	function* clear(tokens) {
+	  let paragraph = ['/'];
+
+	  for (const token of tokens) {
+	    if (isNewLine(token)) {
+	      if (valid(paragraph)) {
+	        yield* paragraph;
+	      }
+
+	      paragraph = [];
+	    }
+
+	    paragraph.push(token);
+	  }
+
+	  if (valid(paragraph)) {
+	    yield* paragraph;
+	  }
+	}
+
+	function toTokens(path) {
+	  const lexTokens = [...lexer(path)];
+	  const tokens = parse(lexTokens);
+	  return [...clear(tokens)];
+	}
+
+	function escapeString(str) {
+	  return decodeURIComponent(str).replace(/([.+*?=^!:${}()[\]|\\])/g, '\\$1');
+	}
+
+	function createSetFn({
+	  name,
+	  modifier,
+	  suffix,
+	  prefix
+	}) {
+	  if (!['*', '+'].includes(modifier) || !prefix && !suffix) {
+	    if (typeof name === 'number') {
+	      return (p, s, k) => p[name + k] = decodeURIComponent(s);
+	    }
+
+	    return (p, s) => p[name] = decodeURIComponent(s);
+	  }
+
+	  const split = prefix + suffix;
+
+	  if (typeof name === 'number') {
+	    return (p, s, k) => {
+	      p[name + k] = s.split(split).map(value => decodeURIComponent(value));
+	    };
+	  }
+
+	  return (p, s) => {
+	    p[name] = s.split(split).map(value => decodeURIComponent(value));
+	  };
+	}
+
+	const defaultPattern = '[^/]+?';
+
+	function tokenToFragment(token, setFns) {
+	  if (typeof token === 'string') {
+	    return escapeString(token);
+	  }
+
+	  const prefix = escapeString(token.prefix);
+	  const suffix = escapeString(token.suffix);
+	  const {
+	    name,
+	    modifier
+	  } = token;
+
+	  if (name === '') {
+	    return `(?:${prefix}${suffix})${modifier}`;
+	  }
+
+	  setFns.push(createSetFn(token));
+	  const pattern = token.pattern || defaultPattern;
+
+	  if (!prefix && !suffix) {
+	    return `((?:${pattern})${modifier})`;
+	  }
+
+	  if (modifier === '?') {
+	    return `(?:${prefix}(${pattern})${suffix})?`;
+	  }
+
+	  if (modifier === '+') {
+	    return `${prefix}(${pattern}(?:${suffix}${prefix}${pattern})*)${suffix}`;
+	  }
+
+	  if (modifier === '*') {
+	    return `(?:${prefix}(${pattern}(?:${suffix}${prefix}${pattern})*)${suffix})?`;
+	  }
+
+	  return `${prefix}(${pattern})${suffix}`;
+	}
+
+	function tokensToRegex(paramsSetters, tokens, end) {
+	  const tokenRegex = tokens.map(t => tokenToFragment(t, paramsSetters));
+	  tokenRegex.unshift('^');
+	  tokenRegex.push(end ? '$' : '(?=/|$)');
+	  return new RegExp(tokenRegex.join(''), 'i');
+	}
+
+	function setParams(paramsSetters, regexExecArray, key, path) {
+	  const params = Object.create(null);
+
+	  for (let i = 1; i < regexExecArray.length; i++) {
+	    const v = regexExecArray[i];
+
+	    if (v === undefined) {
+	      continue;
+	    }
+
+	    const fn = paramsSetters[i];
+
+	    if (!fn) {
+	      continue;
+	    }
+
+	    fn(params, v, key);
+	  }
+
+	  params.$path = path;
+	  return params;
+	}
+
+	function rootMatch(paramsSetters, re, path) {
+	  const res = re.exec(path);
+
+	  if (!res) {
+	    return null;
+	  }
+
+	  return setParams(paramsSetters, res, 0, res[0]);
+	}
+
+	function backMatch(paramsSetters, re, path, parent, key = 0) {
+	  const res = re.exec(path.substring(parent.length));
+
+	  if (!res) {
+	    return null;
+	  }
+
+	  return setParams(paramsSetters, res, key, `${parent}${res[0]}`);
+	}
+
+	function parentMatch(paramsSetters, re, depth, path, parentPath, key = 0) {
+	  const paths = parentPath.split('/').filter(Boolean);
+
+	  if (depth >= paths.length) {
+	    return rootMatch(paramsSetters, re, path);
+	  }
+
+	  const basePath = `/${paths.splice(0, paths.length - depth).join('/')}`;
+	  return backMatch(paramsSetters, re, path, basePath, key);
+	}
+
+	function appendMatch(paramsSetters, re, path, parent, key = 0) {
+	  if (parent[parent.length - 1] === '/') {
+	    parent = parent.substring(0, parent.length - 1);
+	  }
+
+	  return backMatch(paramsSetters, re, path, parent, key);
+	}
+
+	function setKey(tokens) {
+	  let key = 0;
+
+	  for (const token of tokens) {
+	    if (typeof token === 'string') {
+	      continue;
+	    }
+
+	    if (token.name) {
+	      continue;
+	    }
+
+	    if (!token.pattern) {
+	      continue;
+	    }
+
+	    token.name = key++;
+	  }
+
+	  return key;
+	}
+
+	const regex$1 = /^(\.+)\/+/;
+	function createMatch(path, end) {
+	  if (!path || path === '*') {
+	    const match = (_, parent) => ({
+	      $path: parent
+	    });
+
+	    match.keyLen = 0;
+	    return match;
+	  }
+
+	  if (path === '.') {
+	    const match = (path, parent) => {
+	      if (parent[parent.length - 1] === '/') {
+	        parent = parent.substring(0, parent.length - 1);
+	      }
+
+	      const char = path[parent.length];
+
+	      if (char && (char !== '/' || end && path.length - 1 > parent.length)) {
+	        return null;
+	      }
+
+	      const params = Object.create(null);
+	      params.$path = `${parent}${char}`;
+	      return params;
+	    };
+
+	    match.keyLen = 0;
+	    return match;
+	  }
+
+	  const isRoot = path[0] === '/';
+	  let depth = 0;
+
+	  for (let s = regex$1.exec(path); s; s = regex$1.exec(path)) {
+	    const [{
+	      length
+	    }, {
+	      length: len
+	    }] = s;
+	    path = path.substring(length);
+	    depth += len - 1;
+	  }
+
+	  if (depth) {
+	    path = `/${path}`;
+	  }
+
+	  const tokens = toTokens(path);
+	  const key = setKey(tokens);
+	  const paramsSetters = [() => {}];
+	  const re = tokensToRegex(paramsSetters, tokens, end);
+
+	  if (isRoot) {
+	    const match = path => rootMatch(paramsSetters, re, path);
+
+	    match.keyLen = key;
+	    match.isRoot = true;
+	    return match;
+	  }
+
+	  if (depth) {
+	    const match = (...p) => parentMatch(paramsSetters, re, depth, ...p);
+
+	    match.keyLen = key;
+	    return match;
+	  }
+
+	  const match = (...p) => appendMatch(paramsSetters, re, ...p);
+
+	  match.keyLen = key;
+	  return match;
+	}
+
+	function getMethods(methods) {
+	  if (typeof methods === 'string') {
+	    return [methods];
+	  }
+
+	  if (Array.isArray(methods)) {
+	    return methods;
+	  }
+
+	  return ['GET', 'POST', 'PUT', 'DELETE'];
+	}
+
+	function verb(routes, path, handle, options = {}) {
+	  const methods = getMethods(options.methods || handle[methodsSymbol]);
+
+	  if (!methods.length) {
+	    return null;
+	  }
+
+	  const {
+	    controller,
+	    test = handle[testSymbol],
+	    plugin = '',
+	    root = '',
+	    absPath = '',
+	    filePath = '',
+	    name = handle.name
+	  } = options;
+	  const route = {
+	    controller,
+	    root,
+	    absPath,
+	    filePath,
+	    handle,
+	    plugin,
+	    path: path.replace(/(.)\/+$/, '$1').replace(/\/+/g, '/'),
+	    methods,
+	    test,
+	    name,
+	    match: createMatch(path, true)
+	  };
+	  routes.push(route);
+	  return route;
+	}
+
+	/** 方法列表 */
+
+	const methods = new Set(['GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'OPTIONS']);
+
+	function setHandles(routes, path, handles, opt, name = '') {
+	  for (const method of methods) {
+	    const fn = handles[method];
+
+	    if (typeof fn !== 'function') {
+	      continue;
+	    }
+
+	    verb(routes, path, fn, { ...opt,
+	      test: fn[testSymbol] || handles[testSymbol],
+	      methods: [method],
+	      name: name || method
+	    });
+	  }
+	}
+
+	function setHandle(routes, path, item, opt, name = '') {
+	  const options = { ...opt
+	  };
+	  delete options.test;
+	  delete options.methods;
+	  const route = verb(routes, path, item, { ...options,
+	    name
+	  });
+
+	  if (!route) {
+	    return;
+	  }
+
+	  if (route.methods.includes('OPTIONS')) {
+	    return;
+	  }
+
+	  let {
+	    controller,
+	    test,
+	    plugin = '',
+	    root = '',
+	    absPath = '',
+	    filePath = ''
+	  } = opt || {};
+	  path = path.replace(/(.)\/+$/, '$1').replace(/\/+/g, '/');
+	  routes.push({
+	    controller,
+	    root,
+	    absPath,
+	    filePath,
+	    handle: optionsSymbol,
+	    plugin,
+	    path,
+	    methods: ['OPTIONS'],
+	    test,
+	    name: `${name}:OPTIONS`,
+	    match: createMatch(path, true)
+	  });
+	}
+
+	function setHandleItem(routes, path, item, opt, name = '') {
+	  if (!item) {
+	    return;
+	  }
+
+	  if (typeof item === 'object') {
+	    setHandles(routes, path, item, opt, name);
+	  } else if (typeof item === 'function') {
+	    setHandle(routes, path, item, opt, name);
+	  }
+	}
+
+	function initOptions(routes, exports, {
+	  controller,
+	  plugin,
+	  root,
+	  filePath,
+	  absPath
+	} = {}) {
+	  // 公共选项
+	  const options = {
+	    controller: exports.Controller || controller,
+	    plugin,
+	    root,
+	    filePath,
+	    absPath
+	  }; // 将自身添加到路由
+
+	  setHandleItem(routes, '', exports, options);
+	  return options;
+	}
+
+	/** 资源的处理函数配置 */
+
+	const resourceHandleMap = {
+	  index: {
+	    methods: ['GET'],
+	    path: ''
+	  },
+	  create: {
+	    methods: ['POST'],
+	    path: ''
+	  },
+	  new: {
+	    methods: ['GET'],
+	    path: 'new'
+	  },
+	  show: {
+	    methods: ['GET'],
+	    path: ':id'
+	  },
+	  update: {
+	    methods: ['PUT'],
+	    path: ':id'
+	  },
+	  destroy: {
+	    methods: ['DELETE'],
+	    path: ':id'
+	  }
+	};
+	function setResource(routes, exports, options) {
+	  options = initOptions(routes, exports, options);
+
+	  for (const k in exports) {
+	    const item = exports[k];
+
+	    if (!item) {
+	      continue;
+	    }
+
+	    if (!/^[a-z0-9][a-z0-9A-Z_-]*$/.test(k)) {
+	      continue;
+	    } // 特定处理处理函数
+
+
+	    if (typeof item === 'function' && k in resourceHandleMap) {
+	      const info = resourceHandleMap[k];
+	      verb(routes, info.path, item, { ...options,
+	        test: item[testSymbol],
+	        methods: info.methods,
+	        name: k
+	      });
+	      continue;
+	    } // 成员处理函数
+
+
+	    setHandleItem(routes, `:id/${k}`, item, options, k);
+	  }
+	}
+
+	/**
+	 * 处理器
+	 */
+
+	class Controller {
+	  static isControllerConstructor(v) {
+	    if (v === Controller) {
+	      return true;
+	    }
+
+	    if (typeof v !== 'function') {
+	      return false;
+	    }
+
+	    return Controller.isPrototypeOf(v);
+	  }
+
+	  /**
+	   * @warning 不要重载构造函数或者主动调用创建实例
+	   */
+	  constructor(context) {
+	    this.context = context;
+	    Object.defineProperties(this, Object.getOwnPropertyDescriptors(context));
+	  }
+	  /**
+	   * 初始化
+	   * @description 如果有初始化操作，应当在 init 中实现
+	   * @description 此方法由路由调用
+	   */
+
+
+	  [initSymbol]() {}
+	  /** 处理函数的第一个参数 */
+
+
+	  [dataSymbol]() {
+	    const data = { ...this.query
+	    };
+	    const {
+	      body
+	    } = this;
+
+	    if (body && typeof body === 'object') {
+	      Object.assign(data, body);
+	    }
+
+	    Object.assign(data, this.params);
+	    return data;
+	  }
+	  /**
+	   * OPTIONS 的默认处理函数
+	   * @description 如果需要，则需要在此函数中实现
+	   * @description 当已 OPTIONS 方法请求资源，且资源对应的路径中没有定义 OPTIONS 方法处理是的处理函数
+	   */
+
+
+	  [optionsSymbol]() {}
+	  /**
+	   * 对处理函数的结果进行处理
+	   * @description 如果需要自定义处理，需要重载此方法
+	   * @description 此方法由路由调用
+	   * @param result 处理函数的结果
+	   */
+
+
+	  [returnSymbol](result) {
+	    return this.write(result).then(e => {
+	      if (e) {
+	        return;
+	      }
+
+	      if (typeof result !== 'object') {
+	        return;
+	      }
+
+	      this.responseType = 'application/json';
+	      return this.write(JSON.stringify(result));
+	    }).then(() => {});
+	  }
+	  /**
+	   * 处理完成后，实例销毁前，如果有错误未被处理，将回交由此参数处理
+	   * @description 如果需要自定义处理，需要重载此方法
+	   * @description 此方法由路由调用
+	   */
+
+
+	  [catchSymbol](e) {
+	    return this.logs.error(e).then(() => {});
+	  }
+	  /**
+	   * 处理完成后，实例即将销毁时的处理函数
+	   * @description 如果有销毁操作，应当在 finally 中通过实现
+	   * @description 此方法由 destroy 调用
+	   */
+
+
+	  [finallySymbol]() {}
+
+	}
+
+	(function (_Controller) {})(Controller || (Controller = {}));
+
+	var Controller$1 = Controller;
+
+	function setControllerResource(routes, controller, {
+	  plugin = '',
+	  root = '',
+	  absPath = '',
+	  filePath = ''
+	} = {}) {
+	  const {
+	    prototype
+	  } = controller;
+
+	  for (const k in prototype) {
+	    if (typeof prototype[k] !== 'function') {
+	      continue;
+	    }
+
+	    if (!/^[a-z0-9][a-z0-9A-Z_-]*$/.test(k)) {
+	      continue;
+	    } // 特定处理处理函数
+
+
+	    let path = k.replace(/(.)\/+$/, '$1').replace(/\/+/g, '/');
+	    let methods = ['GET', 'POST', 'PUT', 'DELETE'];
+
+	    if (k in resourceHandleMap) {
+	      const info = resourceHandleMap[k];
+	      path = info.path ? `${info.path}` : '';
+	      ({
+	        methods
+	      } = info);
+	    }
+
+	    routes.push({
+	      controller,
+	      root,
+	      absPath,
+	      filePath,
+	      handle: k,
+	      plugin,
+	      path,
+	      methods,
+	      name: k,
+	      match: createMatch(path, true)
+	    });
+	  }
+	}
+
+	class Router {
+	  /** 路由列表 */
+	  constructor(path = '') {
+	    _defineProperty(this, "disabled", false);
+
+	    _defineProperty(this, "__routes", []);
+
+	    _defineProperty(this, "guards", new Set());
+
+	    path = path.replace(/(.)\/+$/, '$1').replace(/\/+/g, '/');
+	    this.path = path;
+	    this.match = createMatch(path, false);
+	  }
+	  /** 子路由 */
+
+
+	  route(path) {
+	    const router = path instanceof Router ? path : new Router(path);
+
+	    this.__routes.push(router);
+
+	    return router;
+	  }
+
+	  verb(path, handle, methods, options) {
+	    if (typeof handle !== 'function') {
+	      return this;
+	    }
+
+	    if (typeof methods === 'string') {
+	      verb(this.__routes, path, handle, { ...options,
+	        methods: [methods]
+	      });
+	    } else if (Array.isArray(methods)) {
+	      verb(this.__routes, path, handle, { ...options,
+	        methods
+	      });
+	    } else {
+	      verb(this.__routes, path, handle, methods);
+	    }
+
+	    return this;
+	  }
+	  /**
+	   * 注册 HTTP GET 处理函数
+	   * @param path    要注册的路径
+	   * @param handle  要注册的处理函数
+	   * @param options 选项
+	   */
+
+
+	  get(path, handle, options) {
+	    if (typeof handle !== 'function') {
+	      return this;
+	    }
+
+	    verb(this.__routes, path, handle, { ...options,
+	      methods: ['GET']
+	    });
+	    return this;
+	  }
+	  /**
+	   * 注册 HTTP POST 处理函数
+	   * @param path    要注册的路径
+	   * @param handle  要注册的处理函数
+	   * @param options 选项
+	   */
+
+
+	  post(path, handle, options) {
+	    if (typeof handle !== 'function') {
+	      return this;
+	    }
+
+	    verb(this.__routes, path, handle, { ...options,
+	      methods: ['POST']
+	    });
+	    return this;
+	  }
+	  /**
+	   * 注册 HTTP PUT 处理函数
+	   * @param path    要注册的路径
+	   * @param handle  要注册的处理函数
+	   * @param options 选项
+	   */
+
+
+	  put(path, handle, options) {
+	    if (typeof handle !== 'function') {
+	      return this;
+	    }
+
+	    verb(this.__routes, path, handle, { ...options,
+	      methods: ['PUT']
+	    });
+	    return this;
+	  }
+	  /**
+	   * 注册 HTTP DELETE 处理函数
+	   * @param path    要注册的路径
+	   * @param handle  要注册的处理函数
+	   * @param options 选项
+	   */
+
+
+	  delete(path, handle, options) {
+	    if (typeof handle !== 'function') {
+	      return this;
+	    }
+
+	    verb(this.__routes, path, handle, { ...options,
+	      methods: ['DELETE']
+	    });
+	    return this;
+	  }
+	  /**
+	   * 注册 HTTP HEAD 处理函数
+	   * @param path    要注册的路径
+	   * @param handle  要注册的处理函数
+	   * @param options 选项
+	   */
+
+
+	  head(path, handle, options) {
+	    if (typeof handle !== 'function') {
+	      return this;
+	    }
+
+	    verb(this.__routes, path, handle, { ...options,
+	      methods: ['HEAD']
+	    });
+	    return this;
+	  }
+	  /**
+	   * 注册 HTTP OPTIONS 处理函数
+	   * @param path    要注册的路径
+	   * @param handle  要注册的处理函数
+	   * @param options 选项
+	   */
+
+
+	  options(path, handle, options) {
+	    if (typeof handle !== 'function') {
+	      return this;
+	    }
+
+	    verb(this.__routes, path, handle, { ...options,
+	      methods: ['OPTIONS']
+	    });
+	    return this;
+	  }
+	  /**
+	   * 注册 HTTP 资源
+	   * @param exports 要注册的资源
+	   * @param options 选项
+	   */
+
+
+	  resource(exports, options) {
+	    setResource(this.__routes, exports, options);
+	    return this;
+	  }
+
+	  register(exports, options) {
+	    if (Controller$1.isControllerConstructor(exports)) {
+	      setControllerResource(this.__routes, exports, options);
+	      return this;
+	    }
+
+	    if (Controller$1.isControllerConstructor(exports.default)) {
+	      setControllerResource(this.__routes, exports.default, options);
+	      return this;
+	    }
+
+	    setResource(this.__routes, exports, options);
+	    return this;
+	  }
+	  /**
+	   * 注册 HTTP 处理函数集
+	   * @param exports 要注册的处理函数集
+	   * @param options 选项
+	   */
+
+
+	  collection(exports, options) {
+	    options = initOptions(this.__routes, exports, options);
+
+	    for (const k in exports) {
+	      if (!/^[a-z0-9][a-z0-9A-Z_-]*$/.test(k)) {
+	        continue;
+	      }
+
+	      setHandleItem(this.__routes, k, exports[k], options, k);
+	    }
+
+	    return this;
+	  }
+	  /**
+	   * 注册 HTTP 资源成员处理函数集
+	   * @param exports 要注册的处理函数集
+	   * @param options 选项
+	   */
+
+
+	  member(exports, options) {
+	    options = initOptions(this.__routes, exports, options);
+
+	    for (const k in exports) {
+	      if (!/^[a-z0-9][a-z0-9A-Z_-]*$/.test(k)) {
+	        continue;
+	      }
+
+	      setHandleItem(this.__routes, `:id/${k}`, exports[k], options);
+	    }
+
+	    return this;
+	  }
+
+	}
+
+	/**
+	 * 路由卫士
+	 * @description 用于路由的过滤及处理函数执行前的预处理
+	 */
+	class Guard extends Service$1 {
+	  decide() {
+	    return true;
+	  }
+	  /**
+	   * 测试请求是否允许通过此路由访问
+	   * @description 同一请求、同一路径下，在此函数中调用的 this.set、this.get、this.delete、this.has、this.keys、this.clear 等方法的数据与实例初始化后的共享。目前不同路径下暂不共享，后续可能会被设计为共享，但不同请求下必然不共享
+	   * @description 同一路径下，若存在任意 test 返回 false 均会使得此路径不会被执行
+	   * @param param 请求参数
+	   */
+
+
+	  static async test(param) {
+	    return true;
+	  }
+	  /**
+	   * @description 映射的 Map 实例的 set 方法，与同一请求同一路径下的 test 共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+	   */
+
+
+	  set(k, v) {
+	    return this;
+	  }
+	  /**
+	   * @description 映射的 Map 实例的 get 方法，与同一请求同一路径下的 test 共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+	   */
+
+
+	  get(k) {
+	    return undefined;
+	  }
+	  /**
+	   * @description 映射的 Map 实例的 delete 方法，与同一请求同一路径下的 test 共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+	   */
+
+
+	  delete(k) {
+	    return false;
+	  }
+	  /**
+	   * @description 映射的 Map 实例的 has 方法，与同一请求同一路径下的 test 共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+	   */
+
+
+	  has(k) {
+	    return false;
+	  }
+	  /**
+	   * @description 映射的 Map 实例的 keys 方法，与同一请求同一路径下的 test 共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+	   */
+
+
+	  *keys() {}
+	  /**
+	   * @description 映射的 Map 实例的 clear 方法，与同一请求同一路径下的 test 共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+	   */
+
+
+	  clear() {}
+	  /**
+	   * @description 映射的 Map 实例的 size 属性，与同一请求同一路径下的 test 共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+	   */
+
+
+	  get size() {
+	    return 0;
+	  }
+	  /**
+	   * @description 映射的 Map 实例的 set 方法，与同一请求同一路径下的 Guard 实例共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+	   */
+
+
+	  static set(k, v) {
+	    return this;
+	  }
+	  /**
+	   * @description 映射的 Map 实例的 get 方法，与同一请求同一路径下的 Guard 实例共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+	   */
+
+
+	  static get(k) {
+	    return undefined;
+	  }
+	  /**
+	   * @description 映射的 Map 实例的 delete 方法，与同一请求同一路径下的 Guard 实例共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+	   */
+
+
+	  static delete(k) {
+	    return false;
+	  }
+	  /**
+	   * @description 映射的 Map 实例的 has 方法，与同一请求同一路径下的 Guard 实例共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+	   */
+
+
+	  static has(k) {
+	    return false;
+	  }
+	  /**
+	   * @description 映射的 Map 实例的 keys 方法，与同一请求同一路径下的 Guard 实例共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+	   */
+
+
+	  static *keys() {}
+	  /**
+	   * @description 映射的 Map 实例的 clear 方法，与同一请求同一路径下的 Guard 实例共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+	   */
+
+
+	  static clear() {}
+	  /**
+	   * @description 映射的 Map 实例的 size 属性，与同一请求同一路径下的 Guard 实例共享同一 Map 实例，此方法会在其他地方重载，常规方式重载无效
+	   */
+
+
+	  static get size() {
+	    return 0;
+	  }
+
+	}
+
+	(function (_Guard) {})(Guard || (Guard = {}));
+
+	var Guard$1 = Guard;
+
+	class ExitSignal extends Error {
+	  /**
+	   * 忽略对退出信号的捕获
+	   * @description 用于 try { } catch(e) {} 的 catch 中忽略退出信号
+	   * @example
+	   * try {
+	   * 	doSomething();
+	   * } catch (e) {
+	   * 	ExitSignal.assert(e);
+	   * 	customProcess(e);
+	   * }
+	   */
+	  static assert(v) {
+	    if (v instanceof ExitSignal) {
+	      throw v;
+	    }
+	  }
+
+	}
+
+	class Plugin {
+	  /** 包名 */
+
+	  /** 版本 */
+
+	  /** 作者 */
+
+	  /** 开源协议 */
+	  constructor(name,
+	  /** 版本 */
+	  version, {
+	    author,
+	    license
+	  } = {}) {
+	    this.name = name;
+	    this.version = typeof version === 'string' ? version : '';
+	    this.author = typeof author === 'string' ? author : '';
+	    this.license = typeof license === 'string' ? license : '';
+	  }
+
+	  _initRouter(router) {}
+
+	  initRouter() {
+	    if (this.__initRouterPromise) {
+	      return this.__initRouterPromise;
+	    }
+
+	    const {
+	      router
+	    } = this;
+	    return this.__initRouterPromise = Promise.resolve().then(() => this._initRouter(router)).then(() => router);
+	  }
+
+	  get router() {
+	    const router = new Router();
+	    Reflect.defineProperty(this, 'router', {
+	      value: router,
+	      configurable: true
+	    });
+	    this.initRouter();
+	    return router;
+	  }
+
+	  get disabled() {
+	    return this.router.disabled;
+	  }
+
+	  set disabled(t) {
+	    this.router.disabled = t;
+	  }
+
+	}
+
+	function relateMap(obj, maps, key) {
+	  let map = maps.get(key);
+
+	  if (!map) {
+	    map = new Map();
+	    maps.set(key, map);
+	  }
+
+	  Object.defineProperties(obj, {
+	    set: {
+	      configurable: true,
+
+	      value(k, v) {
+	        map.set(k, v);
+	        return this;
+	      }
+
+	    },
+	    get: {
+	      configurable: true,
+	      value: k => map.get(k)
+	    },
+	    delete: {
+	      configurable: true,
+	      value: k => map.delete(k)
+	    },
+	    has: {
+	      configurable: true,
+	      value: k => map.has(k)
+	    },
+	    keys: {
+	      configurable: true,
+	      value: () => map.keys()
+	    },
+	    clear: {
+	      configurable: true,
+	      value: () => map.clear()
+	    },
+	    size: {
+	      configurable: true,
+	      get: () => map.size
+	    }
+	  });
+	  return obj;
+	}
+
+	async function preprocess(guards, data, params) {
+	  for (let p of guards) {
+	    const pClass = relateMap(Object.create(p), data, p);
+
+	    try {
+	      if (!(await pClass.test(params))) {
+	        return false;
+	      }
+	    } catch {
+	      return false;
+	    }
+	  }
+
+	  return true;
+	}
+
+	function methodVerify(methods, method) {
+	  if (!methods.length) {
+	    return true;
+	  }
+
+	  if (methods.includes(method)) {
+	    return true;
+	  }
+
+	  return false;
+	}
+
+	async function runTest({
+	  test
+	}, params) {
+	  if (typeof test !== 'function') {
+	    return true;
+	  } // 有效性验证
+
+
+	  try {
+	    return await test(params);
+	  } catch {
+	    return false;
+	  }
+	}
+
+	async function matchRoute(route, method, path, baseParams, parentPath, key) {
+	  if (!methodVerify(route.methods, method)) {
+	    return null;
+	  }
+
+	  const {
+	    match
+	  } = route;
+	  const result = match(path, parentPath, key);
+
+	  if (!result) {
+	    return null;
+	  }
+
+	  const params = match.isRoot ? result : { ...baseParams,
+	    ...result
+	  };
+
+	  if (false === (await runTest(route, params))) {
+	    return null;
+	  }
+
+	  return params;
+	}
+
+	async function find(router, method, path, throughData, baseParams, routers, parentPath, key) {
+	  if (router.disabled) {
+	    return null;
+	  }
+
+	  const {
+	    match
+	  } = router;
+	  const result = match(path, parentPath, key);
+
+	  if (!result) {
+	    return null;
+	  }
+
+	  const params = match.isRoot ? result : { ...baseParams,
+	    ...result
+	  }; // 预处理
+
+	  if (!preprocess([...router.guards], throughData, params)) {
+	    return null;
+	  }
+
+	  const newRouters = [...routers, router];
+	  const keyLen = match.isRoot ? match.keyLen : match.keyLen + key;
+	  const thisPath = result.$path;
+
+	  for (const item of Array.from(router.__routes)) {
+	    if (item instanceof Router) {
+	      const res = await find(item, method, path, throughData, params, newRouters, thisPath, keyLen);
+
+	      if (res) {
+	        return res;
+	      }
+
+	      continue;
+	    }
+
+	    const pathParams = await matchRoute(item, method, path, params, thisPath, keyLen);
+
+	    if (!pathParams) {
+	      continue;
+	    }
+
+	    return {
+	      route: item,
+	      routers: newRouters,
+	      params: pathParams
+	    };
+	  }
+
+	  return null;
+	}
+
+	function buff2str(buffer) {
+	  const code = new Uint8Array(buffer);
+	  let ret = [];
+	  let index = 0;
+
+	  while (index < code.length) {
+	    let c = code[index++] | 0;
+
+	    if (c > 0b11100000) {
+	      c = (c & 0xF) << 12;
+	      c |= (code[index++] & 0x3F) << 6;
+	      c |= code[index++] & 0x3F;
+	    } else if (c > 0b11000000) {
+	      c = (c & 0x1F) << 12;
+	      c |= code[index++] & 0x3F;
+	    }
+
+	    ret.push(c);
+	  }
+
+	  return ret.map(x => String.fromCharCode(x)).join('');
+	}
+
+	function mergeArrayBuffer(data, length = data.reduce((a, b) => a + b.byteLength, 0)) {
+	  if (data.length === 1) {
+	    return data[0];
+	  }
+
+	  const array = new Uint8Array(length);
+	  let offset = 0;
+
+	  for (const b of data) {
+	    for (let k of new Uint8Array(b)) {
+	      array[offset++] = k;
+	    }
+	  }
+
+	  return array.buffer;
+	}
+
+	function getBuffer(encoding, data, size) {
+	  if (!size) {
+	    const buffer = mergeArrayBuffer(data);
+	    return encoding ? buff2str(buffer) : buffer;
+	  }
+
+	  let length = 0;
+
+	  for (let it; it = data.shift();) {
+	    if (length + it.byteLength > size) {
+	      const buffer = it.slice(0, size - length);
+	      length += buffer.byteLength;
+	      data.unshift(it.slice(buffer.byteLength));
+	      break;
+	    }
+	    length += it.byteLength;
+
+	    if (length === size) {
+	      break;
+	    }
+	  }
+
+	  const buffer = mergeArrayBuffer(data, length);
+	  return encoding ? buff2str(buffer) : buffer;
+	}
+
+	function str2buff(str) {
+	  let out = [];
+
+	  for (let c of str.split('').map(ch => ch.charCodeAt(0))) {
+	    if (c < 0x80) {
+	      out.push(c);
+	    } else if (c < 0x800) {
+	      out.push(0xC0 | 0x1F & c >> 6);
+	      out.push(0x80 | 0x3F & c);
+	    } else {
+	      out.push(0xE0 | 0x0F & c >> 12);
+	      out.push(0x80 | 0x3F & c >> 6);
+	      out.push(0x80 | 0x3F & c);
+	    }
+	  }
+
+	  return new Uint8Array(out).buffer;
+	}
+
+	function toBuffer(chunk) {
+	  if (typeof chunk === 'string') {
+	    return str2buff(chunk);
+	  }
+
+	  if (ArrayBuffer.isView(chunk)) {
+	    return chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
+	  }
+
+	  return chunk;
+	}
+
+	function isBaseWriteType$1(chunk) {
+	  if (chunk instanceof ArrayBuffer) {
+	    return true;
+	  }
+
+	  if (ArrayBuffer.isView(chunk)) {
+	    return true;
+	  }
+
+	  try {
+	    if (chunk instanceof SharedArrayBuffer) {
+	      return true;
+	    }
+	  } catch {}
+
+	  return false;
+	}
+
+	async function* toAsyncIterable(chunk) {
+	  if (!chunk) {
+	    return;
+	  }
+
+	  if (typeof chunk === 'string') {
+	    return yield chunk;
+	  }
+
+	  if (typeof chunk !== 'object') {
+	    return;
+	  }
+
+	  if (isBaseWriteType$1(chunk)) {
+	    return yield chunk;
+	  }
+
+	  if (!(Symbol.asyncIterator in chunk || Symbol.iterator in chunk)) {
+	    return;
+	  }
+
+	  for await (const data of chunk) {
+	    yield* toAsyncIterable(data);
+	  }
+	}
+
+	async function main$1(req, getNext) {
+	  const data = [];
+	  let length = 0;
+	  let [size, encoding, cb] = await getNext();
+
+	  for await (const v of toAsyncIterable(req)) {
+	    const buffer = toBuffer(v);
+	    data.push(buffer);
+	    length += buffer.byteLength;
+
+	    if (size <= 0) {
+	      length = 0;
+	      cb(getBuffer(encoding, data));
+	      [size, encoding, cb] = await getNext();
+	      continue;
+	    }
+
+	    if (length >= size) {
+	      length -= size;
+	      cb(getBuffer(encoding, data, size));
+	      [size, encoding, cb] = await getNext();
+	    }
+
+	    while (length && (size <= 0 || size <= length)) {
+	      if (size <= 0) {
+	        length = 0;
+	        cb(getBuffer(encoding, data));
+	        [size, encoding, cb] = await getNext();
+	        break;
+	      }
+
+	      length -= size;
+	      cb(getBuffer(encoding, data, size));
+	      [size, encoding, cb] = await getNext();
+	    }
+	  }
+
+	  if (length) {
+	    cb(getBuffer(encoding, data));
+	    [size, encoding, cb] = await getNext();
+	  }
+
+	  cb(null);
+
+	  for (;;) {
+	    [size, encoding, cb] = await getNext();
+	    cb(null);
+	  }
+	}
+
+	function createRead(req) {
+	  if (!req) {
+	    return () => Promise.resolve(null);
+	  }
+
+	  const list = [];
+	  let next = null;
+	  main$1(req, function getNext() {
+	    return new Promise(r => {
+	      const t = list.shift();
+
+	      if (t) {
+	        return r(t);
+	      }
+
+	      next = v => {
+	        next = null;
+	        r(v);
+	      };
+	    });
+	  });
+
+	  function read(size = 0, encoding = false) {
+	    return new Promise(resolve => {
+	      size = Math.max(size, 0);
+
+	      if (next) {
+	        next([size, encoding, resolve]);
+	        return;
+	      }
+
+	      list.push([size, encoding, resolve]);
+	    });
+	  }
+
+	  return read;
+	}
+
+	const urlRegex = /^(?:(?:https?:)?\/\/(?:(?:[^/?#]*@)?)(?:\d+|(?:\[[0-9a-f:]+\])|(?:\d{1,3}\.){3}\d{1,3}|(?:(?:[a-z0-9\u0100-\uffff]+-*)+\.)+[a-z]+)(?::\d+)?)?((?:\/?[^?#]*)?)((?:\?[^#]*)?)(?:#.*)?$/i;
+
+	function getNameValue(s) {
+	  const index = s.indexOf('=');
+
+	  if (index < 0) {
+	    return [decodeURIComponent(s), ''];
+	  }
+
+	  return [decodeURIComponent(s.substring(0, index)), decodeURIComponent(s.substring(index + 1))];
+	}
+
+	function parseQuery(s) {
+	  const query = {};
+
+	  for (const k of s.split('&').filter(Boolean)) {
+	    const [index, value] = getNameValue(k);
+
+	    if (index in query) {
+	      query[index] = [query[index], value].flat();
+	    } else {
+	      query[index] = [value];
+	    }
+	  }
+
+	  return query;
+	}
+
+	function parseUrl(uri) {
+	  const result = urlRegex.exec(uri);
+
+	  if (!result) {
+	    return ['/', ''];
+	  }
+
+	  let [, pathname, search] = result;
+	  const path = [];
+
+	  for (const p of pathname.replace(/^[\\/]+/, '').replace(/[\\/]+/g, '/').split('/')) {
+	    if (p === '.') {
+	      continue;
+	    }
+
+	    if (p === '..') {
+	      path.pop();
+	      continue;
+	    }
+
+	    path.push(p);
+	  }
+
+	  return [`/${path.join('/')}`, search];
+	}
+
+	function createRequest(method, path, body, headers = {}) {
+	  const [pathname, search] = parseUrl(path);
+	  return {
+	    method,
+	    url: `${pathname}${search}`,
+	    headers,
+	    pathname,
+	    search,
+	    query: parseQuery(search.substring(1)),
+	    read: typeof body === 'function' ? body : createRead(body)
+	  };
+	}
+
+	function createWrite() {
+	  let list = [];
+	  let ended = false;
+	  let endCb = null;
+	  let next = null;
+
+	  function run() {
+	    if (!next) {
+	      return;
+	    }
+
+	    next(list.shift() || null);
+	  }
+
+	  function write(data) {
+	    return new Promise(cb => {
+	      if (endCb || ended) {
+	        return cb(false);
+	      }
+
+	      list.push([data, cb]);
+	      run();
+	    });
+	  }
+
+	  let endPromise = null;
+
+	  function end() {
+	    if (!endPromise) {
+	      endPromise = new Promise(cb => {
+	        if (ended) {
+	          return cb();
+	        }
+
+	        endCb = cb;
+	        run();
+	      });
+	    }
+
+	    return endPromise;
+	  }
+
+	  function getEndFn() {
+	    return endCb;
+	  }
+
+	  function get() {
+	    return new Promise(r => {
+	      const value = list.shift();
+
+	      if (value) {
+	        return r(value);
+	      }
+
+	      if (endCb) {
+	        return r(null);
+	      }
+
+	      next = v => {
+	        next = null;
+	        r(v);
+	      };
+	    });
+	  }
+
+	  const asyncIterable = async function* () {
+	    try {
+	      for (;;) {
+	        const value = await get();
+
+	        if (value) {
+	          const [data, cb] = value;
+
+	          try {
+	            yield data;
+	            cb(true);
+	          } catch {
+	            cb(false);
+	          }
+
+	          continue;
+	        }
+
+	        if (getEndFn()) {
+	          break;
+	        }
+	      }
+	    } finally {
+	      ended = true; // eslint-disable-next-line no-cond-assign
+
+	      for (let value; value = list.shift();) {
+	        const [, cb] = value;
+	        cb(false);
+	      }
+
+	      const endFn = getEndFn();
+
+	      if (endFn) {
+	        endFn();
+	      }
+	    }
+	  }();
+
+	  return [write, end, asyncIterable, () => ended];
+	}
+
+	function isServiceFunc(t) {
+	  return typeof Service$1 === 'function';
+	}
+
+	function isServiceConstructor(t) {
+	  return Service$1.isPrototypeOf(t);
+	}
+
+	function runService(services, throughData, context, Service, p) {
+	  if (!isServiceConstructor(Service)) {
+	    if (isServiceFunc()) {
+	      return Service(context, ...p);
+	    }
+
+	    throw new TypeError('the object not is service class or function');
+	  }
+
+	  let service = services.get(Service);
+
+	  if (service) {
+	    return service.export(...p);
+	  }
+
+	  service = new Service(context);
+	  services.set(Service, service);
+
+	  if (Guard$1.isPrototypeOf(Service)) {
+	    relateMap(service, throughData, Service);
+	  }
+
+	  return service.export(...p);
+	}
+
+	function isBaseWriteType(chunk) {
+	  if (chunk instanceof ArrayBuffer) {
+	    return true;
+	  }
+
+	  if (ArrayBuffer.isView(chunk)) {
+	    return true;
+	  }
+
+	  try {
+	    if (chunk instanceof SharedArrayBuffer) {
+	      return true;
+	    }
+	  } catch {}
+
+	  return false;
+	}
+	/**
+	 * 向可写流中写入数据
+	 * @param writable 可写流
+	 * @param chunk    要写入的数据
+	 * @param encoding 如果要写入的数据是字符串，则可用此参数指定编码
+	 */
+
+
+	async function writeData(write, isEnd, chunk) {
+	  if (!chunk) {
+	    return false;
+	  }
+
+	  if (isEnd()) {
+	    return true;
+	  }
+
+	  if (typeof chunk === 'string') {
+	    return write(chunk);
+	  }
+
+	  if (typeof chunk !== 'object') {
+	    return false;
+	  }
+
+	  if (isBaseWriteType(chunk)) {
+	    return write(chunk);
+	  }
+
+	  if (!(Symbol.asyncIterator in chunk || Symbol.iterator in chunk)) {
+	    return false;
+	  }
+
+	  for await (const data of chunk) {
+	    if (isEnd()) {
+	      return true;
+	    }
+
+	    if (!(await writeData(write, isEnd, data))) {
+	      return false;
+	    }
+	  }
+
+	  return true;
+	}
+
+	function clearCookie(sentCookies, cookies, name, opt) {
+	  let expire = 'Fri, 31 Dec 1999 16:00:00 GMT';
+
+	  if (typeof name === 'string') {
+	    if (!name) {
+	      return;
+	    }
+
+	    const {
+	      domain,
+	      path,
+	      secure,
+	      httpOnly
+	    } = opt !== true && opt || {};
+	    sentCookies.push({
+	      name,
+	      value: 'delete',
+	      expire,
+	      domain,
+	      path,
+	      secure,
+	      httpOnly
+	    });
+	  } else {
+	    const {
+	      domain,
+	      path,
+	      secure,
+	      httpOnly
+	    } = name || {};
+	    sentCookies.length = 0;
+
+	    if (opt) {
+	      for (let name in cookies) {
+	        sentCookies.push({
+	          name,
+	          value: 'delete',
+	          expire,
+	          domain,
+	          path,
+	          secure,
+	          httpOnly
+	        });
+	      }
+	    }
+	  }
+	}
+
+	function* getCookie(sentCookies, name) {
+	  const list = sentCookies;
+
+	  for (const item of list) {
+	    if (name && item.name !== name) {
+	      continue;
+	    }
+
+	    yield { ...item
+	    };
+	  }
+	}
+
+	function getRequestCookies(cookie) {
+	  let cookies = {};
+
+	  for (const item of cookie.replace(/\s/g, '').split(';')) {
+	    const v = item.split('=');
+	    const name = decodeURIComponent(v.shift());
+	    cookies[name] = decodeURIComponent(v.join('='));
+	  }
+
+	  return cookies;
+	}
+
+	function getCookieHeader(list) {
+	  return list.map(({
+	    name,
+	    value,
+	    expire,
+	    domain,
+	    path,
+	    secure,
+	    httpOnly
+	  }) => name && [`${encodeURI(name)}=${encodeURI(value || '')}`, expire && `Expires=${expire}`, domain && `Domain=${encodeURI(domain)}`, path && `Path=${encodeURI(path)}`, secure && 'Secure', httpOnly && 'HttpOnly'].filter(Boolean).join('; ')).filter(Boolean);
+	}
+
+	const hostRegex = /^(\[[^\]]+\]|^:):(\d+)$/;
+	function createContext(app, params, plugin, throughData, {
+	  method,
+	  url,
+	  pathname,
+	  search,
+	  query,
+	  read,
+	  headers: { ...headers
+	  }
+	}) {
+	  const [write, end, asyncIterable, ended] = createWrite();
+	  let headersSent = false;
+	  let statusCode = 200;
+	  let resHeaders = {};
+	  let resolve;
+	  let value;
+
+	  function send() {
+	    if (headersSent) {
+	      return;
+	    }
+
+	    headersSent = true;
+	    value = {
+	      get statusCode() {
+	        return statusCode;
+	      },
+
+	      get finished() {
+	        return ended();
+	      },
+
+	      headers: Object.freeze({ ...resHeaders
+	      }),
+
+	      [Symbol.asyncIterator]() {
+	        return asyncIterable;
+	      }
+
+	    };
+
+	    if (resolve) {
+	      resolve(value);
+	    }
+	  }
+
+	  Object.freeze(headers);
+	  const host = headers.host || '';
+	  const hostInfo = hostRegex.exec(host);
+	  const [hostname, port] = hostInfo ? [hostInfo[1], hostInfo[2]] : [host, ''];
+	  const sentCookies = [];
+	  const cookies = getRequestCookies(headers['cookie'] || '');
+	  const services = new Map();
+	  let destroyed = false;
+
+	  function isEnd() {
+	    return destroyed || ended();
+	  }
+
+	  let body;
+	  let data;
+
+	  function setData(d) {
+	    data = d;
+	  }
+
+	  const context = {
+	    get body() {
+	      return body;
+	    },
+
+	    set body(b) {
+	      body = b;
+	    },
+
+	    get data() {
+	      return data;
+	    },
+
+	    app,
+	    settings: plugin ? app.settings(plugin, true) : app.settings,
+	    assets: plugin ? app.assets(plugin, true) : app.assets,
+	    logs: plugin ? app.logs(plugin, true) : app.logs,
+	    plugin,
+	    params,
+	    url,
+	    method,
+	    pathname,
+	    search,
+	    query,
+	    headers,
+	    referer: headers.referer || '',
+	    host,
+	    hostname,
+	    port,
+	    userAgent: headers['user-agent'] || '',
+	    accept: (headers.accept || '').split(/,\s*/).filter(Boolean),
+	    acceptLanguage: (headers['accept-language'] || '').split(/,\s*/).filter(Boolean),
+	    cookies,
+	    read,
+
+	    /** 当前对象是否已经被销毁 */
+	    get destroyed() {
+	      return destroyed;
+	    },
+
+	    /** 相应是否已结束 */
+	    get finished() {
+	      return ended();
+	    },
+
+	    /** 响应头是否已经被发送 */
+	    get headersSent() {
+	      return headersSent;
+	    },
+
+	    /** 状态码 */
+	    get status() {
+	      return statusCode;
+	    },
+
+	    set status(v) {
+	      if (headersSent) {
+	        return;
+	      }
+
+	      statusCode = v;
+	    },
+
+	    /**
+	     * 获取已设置的 cookie 信息
+	     */
+	    getCookie(name) {
+	      return getCookie(sentCookies, name);
+	    },
+
+	    /**
+	     * 设置 cookie
+	     * @param name cookie 名称
+	     * @param value cookie 内容
+	     * @param option 选项
+	     */
+	    setCookie(name, value, {
+	      expire,
+	      domain,
+	      path,
+	      secure,
+	      httpOnly
+	    } = {}) {
+	      if (headersSent) {
+	        return;
+	      }
+
+	      sentCookies.push({
+	        name,
+	        value,
+	        expire,
+	        domain,
+	        path,
+	        secure,
+	        httpOnly
+	      });
+	      resHeaders['set-cookie'] = getCookieHeader(sentCookies);
+	    },
+
+	    clearCookie(name, opt) {
+	      if (headersSent) {
+	        return;
+	      }
+
+	      clearCookie(sentCookies, cookies, name, opt);
+	      resHeaders['set-cookie'] = getCookieHeader(sentCookies);
+	    },
+
+	    service(Service, ...p) {
+	      if (destroyed) {
+	        throw new Error('This controller is destroyed');
+	      }
+
+	      return runService(services, throughData, context, Service, p);
+	    },
+
+	    /** 获取请求头中的 contentType */
+	    get requestType() {
+	      return headers['content-type'] || '';
+	    },
+
+	    /** 相应头中的 contentType */
+	    get responseType() {
+	      return resHeaders['content-type'] || '';
+	    },
+
+	    set responseType(v) {
+	      if (!headersSent) {
+	        resHeaders['content-type'] = v;
+	      }
+	    },
+
+	    hasHeader(n) {
+	      return n in resHeaders;
+	    },
+
+	    getHeaderNames() {
+	      return Object.keys(resHeaders);
+	    },
+
+	    getHeaders() {
+	      return { ...resHeaders
+	      };
+	    },
+
+	    getHeader(n) {
+	      return resHeaders[n];
+	    },
+
+	    removeHeader(n) {
+	      if (!headersSent) {
+	        delete resHeaders[n];
+	      }
+	    },
+
+	    setHeader(n, v) {
+	      if (headersSent) {
+	        return;
+	      }
+
+	      if (v === undefined) {
+	        delete resHeaders[n];
+	      } else {
+	        resHeaders[n] = v;
+	      }
+	    },
+
+	    async write(chunk) {
+	      if (!chunk) {
+	        return true;
+	      }
+
+	      send();
+
+	      if (isEnd()) {
+	        return true;
+	      }
+
+	      return writeData(write, isEnd, chunk);
+	    },
+
+	    exit(status) {
+	      if (typeof status === 'number' && status >= 100 && status < 700) {
+	        statusCode = status;
+	      }
+
+	      throw new ExitSignal();
+	    },
+
+	    transfer(url, is301) {
+	      statusCode = is301 ? 301 : 302;
+
+	      if (!headersSent) {
+	        resHeaders['location'] = url;
+	      }
+
+	      throw new ExitSignal();
+	    },
+
+	    request(method, path, {
+	      headers,
+	      body
+	    } = {}) {
+	      return app.request(createRequest(method, path, body, headers));
+	    }
+
+	  };
+
+	  async function destroy() {
+	    if (destroyed) {
+	      return;
+	    }
+
+	    destroyed = true;
+
+	    for (const c of [...services.values()]) {
+	      try {
+	        await c.destroy();
+	      } catch (e) {
+	        app.logs.error(e);
+	      }
+	    }
+
+	    send();
+	    return end();
+	  }
+
+	  const response = new Promise(r => {
+	    if (headersSent && value) {
+	      r(value);
+	    } else {
+	      resolve = r;
+	    }
+	  });
+
+	  async function runGuards(guards) {
+	    for (const Guard of guards) {
+	      let guard = services.get(Guard);
+
+	      if (!guard) {
+	        guard = new Guard(context);
+	        relateMap(guard, throughData, Guard);
+	        services.set(Guard, guard);
+	      }
+
+	      if (false === (await guard.decide())) {
+	        return false;
+	      }
+	    }
+
+	    return true;
+	  }
+
+	  return {
+	    context,
+	    destroy,
+	    setData,
+	    response,
+	    runGuards
+	  };
+	}
+
+	function findController(routers, {
+	  controller
+	}) {
+	  if (Controller$1.isControllerConstructor(controller)) {
+	    return controller;
+	  }
+
+	  for (const {
+	    controller
+	  } of [...routers].reverse()) {
+	    if (Controller$1.isControllerConstructor(controller)) {
+	      return controller;
+	    }
+	  }
+
+	  return Controller$1;
+	}
+
+	function* getGuards(routers) {
+	  for (const {
+	    guards
+	  } of [...routers]) {
+	    yield* guards;
+	  }
+	}
+
+	function returnResult(result, controller, context) {
+	  if (context.finished) {
+	    return;
+	  }
+
+	  if (!result) {
+	    return;
+	  }
+
+	  if (context === result) {
+	    return;
+	  }
+
+	  if (controller === result) {
+	    return;
+	  }
+
+	  return controller[returnSymbol](result);
+	}
+
+	async function exec(handle, controller, context, data) {
+	  if (typeof handle === 'function') {
+	    const result = await handle.call(context, data);
+	    return returnResult(result, controller, context);
+	  }
+
+	  if (typeof handle === 'string') {
+	    const fn = controller[handle];
+
+	    if (typeof fn !== 'function') {
+	      return;
+	    }
+
+	    const result = await fn.call(controller);
+	    return returnResult(result, controller, context);
+	  }
+
+	  if (handle === optionsSymbol) {
+	    const result = await controller[optionsSymbol]();
+	    return returnResult(result, controller, context);
+	  }
+	}
+
+	async function catchError(app, controller, e) {
+	  if (e instanceof ExitSignal) {
+	    return;
+	  }
+
+	  try {
+	    await controller[catchSymbol](e);
+	  } catch (e) {
+	    app.logs.error(e);
+	  }
+	}
+
+	async function main(app, route, controller, context, runGuards, routers, destroy, setData) {
+	  try {
+	    // 初始化
+	    await controller[initSymbol]();
+
+	    if (!(await runGuards(getGuards(routers)))) {
+	      return;
+	    }
+
+	    const data = await controller[dataSymbol]();
+	    setData(data);
+	    await exec(route.handle, controller, context, data);
+	  } catch (e) {
+	    await catchError(app, controller, e);
+	  } finally {
+	    try {
+	      await controller[finallySymbol]();
+	    } catch (e) {
+	      app.logs.error(e);
+	    } // 销毁与回收处理
+
+
+	    await destroy();
+	  }
+	}
+
+	function run(app, throughData, routers, route, request, params) {
+	  const {
+	    context,
+	    destroy,
+	    setData,
+	    response,
+	    runGuards
+	  } = createContext(app, params, route.plugin, throughData, request);
+	  const ThisController = findController(routers, route);
+	  const controller = new ThisController(context);
+	  main(app, route, controller, context, runGuards, routers, destroy, setData);
+	  return response;
+	}
+
+	/** 查找请求的处理函数 */
+
+	async function callback(request) {
+	  const throughData = new Map();
+	  const it = await find(this, request.method, request.pathname, throughData, {}, [], '', 0);
+
+	  if (!it) {
+	    return null;
+	  }
+
+	  return run(this, throughData, it.routers, it.route, request, it.params);
+	}
+
+	const dotRegex = /^\.+$/;
+
+	function resolvePath(...paths) {
+	  const list = [];
+
+	  for (const k of paths.map(p => p.split('/')).flat()) {
+	    if (!k || k === '.') {
+	      continue;
+	    }
+
+	    if (dotRegex.test(k)) {
+	      list.length = Math.max(0, list.length - k.length + 1);
+	      continue;
+	    }
+
+	    list.push(k);
+	  }
+
+	  return `${list.join('/')}`;
+	}
+	/** 自扩展接口 */
+
+
+	function subInterface(interfaces, extendsInterfaces, mark, basePath, path, setMark) {
+	  if (path === undefined) {
+	    return basePath;
+	  }
+
+	  if (path === '~') {
+	    path = mark;
+	  } else if (path.substr(0, 2) === '~/') {
+	    path = `${mark}/${path.substr(2)}`;
+	  } else if (path.substr(0, 2) === '\\~') {
+	    path = path.substr(1);
+	  }
+
+	  return Interface(interfaces, extendsInterfaces, setMark ? resolvePath(path) : mark, setMark ? '' : path, basePath);
+	}
+	/** 自扩展接口 */
+
+
+	function Interface(interfaces, extendsInterfaces, mark = '', path = '', basePath = '') {
+	  basePath = resolvePath(basePath, path);
+	  const ret = subInterface.bind(null, interfaces, extendsInterfaces, mark, basePath);
+
+	  for (const k in interfaces) {
+	    const v = interfaces[k];
+	    ret[k] = typeof v === 'function' ? (path, ...p) => v(resolvePath(basePath, path), ...p) : v;
+	  }
+
+	  if (!extendsInterfaces) {
+	    return ret;
+	  }
+
+	  for (const k in extendsInterfaces) {
+	    ret[k] = extendsInterfaces[k];
+	  }
+
+	  return ret;
+	}
+
+	/**
+	 * 包装日志文本
+	 * @param log 原始的日志
+	 * @param opt 包装选项
+	 */
+
+	function pack(log, {
+	  tags,
+	  indent
+	}) {
+	  let extendInfo = '';
+
+	  if (tags) {
+	    if (!Array.isArray(tags)) {
+	      tags = [tags];
+	    }
+
+	    extendInfo = tags.map(tag => `[${tag}]`).join(' ');
+	  }
+
+	  extendInfo = `${new Date().toISOString()} ${extendInfo}`;
+
+	  if (!log.includes('\n')) {
+	    return `${extendInfo} ${log}`;
+	  }
+
+	  if (typeof indent === 'number') {
+	    indent = Math.floor(indent);
+
+	    if (isFinite(indent) && indent > 0) {
+	      indent = Array(indent).fill(' ').join('');
+	    }
+	  }
+
+	  if (!indent || typeof indent !== 'string') {
+	    indent = '  ';
+	  }
+
+	  log = `${extendInfo}\n${log}`;
+	  log = log.split('\n').join(`\n${indent}`);
+	  return log;
+	}
+
+	function getErrorLog(log) {
+	  if (typeof log === 'string') {
+	    return log;
+	  }
+
+	  if (log instanceof Error) {
+	    return log.stack || `${log.name}:${log.message}`;
+	  }
+
+	  return String(log);
+	}
+	const regex1 = /(?:^|\/)(debug|error|warn|info)\/?$/;
+	const regex2 = /^\/?(debug|error|warn|info)(?:\/|$)/;
+
+	function getType(path) {
+	  const v1 = regex1.exec(path);
+
+	  if (v1) {
+	    return v1[1];
+	  }
+
+	  const v2 = regex2.exec(path);
+
+	  if (v2) {
+	    return v2[1];
+	  }
+
+	  return '';
+	}
+
+	async function defaultRead$2() {
+	  return '';
+	}
+
+	function defaultWriteInPath(path, log) {
+	  console.group(`log @ ${path}`);
+
+	  switch (getType(path)) {
+	    case 'debug':
+	      console.debug(log);
+	      break;
+
+	    case 'info':
+	      console.info(log);
+	      break;
+
+	    case 'warn':
+	      console.warn(log);
+	      break;
+
+	    case 'error':
+	      console.error(log);
+	      break;
+
+	    default:
+	      console.log(log);
+	      break;
+	  }
+
+	  console.groupEnd();
+	}
+
+	async function defaultWrite$2(path, log) {
+	  switch (path) {
+	    case 'debug':
+	      console.debug(log);
+	      break;
+
+	    case 'info':
+	      console.info(log);
+	      break;
+
+	    case 'warn':
+	      console.warn(log);
+	      break;
+
+	    case 'error':
+	      console.error(log);
+	      break;
+
+	    default:
+	      defaultWriteInPath(path, log);
+	      break;
+	  }
+
+	  return true;
+	}
+
+	async function defaultClear() {}
+
+	function initLog({
+	  read = defaultRead$2,
+	  write = defaultWrite$2,
+	  clear = defaultClear
+	} = {}) {
+	  function readLog(path) {
+	    return read(path);
+	  }
+
+	  function clearLog(path) {
+	    return clear(path);
+	  }
+
+	  function writeLog(path, log, opt) {
+	    if (opt) {
+	      log = pack(log, opt);
+	    }
+
+	    if (log[log.length - 1] !== '\n') {
+	      log += '\n';
+	    }
+
+	    return write(path, log);
+	  }
+
+	  return Interface({
+	    read: readLog,
+	    write: writeLog,
+	    clear: clearLog
+	  }, {
+	    async debug(log, opt) {
+	      return writeLog('debug', log, opt);
+	    },
+
+	    async info(log, opt) {
+	      return writeLog('info', log, opt);
+	    },
+
+	    async warn(log, opt) {
+	      return writeLog('warn', getErrorLog(log), opt);
+	    },
+
+	    async error(log, opt) {
+	      return writeLog('error', getErrorLog(log), opt);
+	    }
+
+	  });
+	}
+
+	const idRegexText = '[a-zA-Z][a-zA-Z0-9_-]*';
+	const kRegexText = `${idRegexText}(?:.${idRegexText})*`;
+	const regexText = `^/plugins/((?:@${kRegexText}/)?${kRegexText})/(.+)$`;
+	const regex = new RegExp(regexText);
+	function getPluginPath(path, plugins) {
+	  if (!plugins) {
+	    return null;
+	  }
+
+	  const r = regex.exec(path);
+
+	  if (!r) {
+	    return null;
+	  }
+
+	  const plugin = plugins[r[1]];
+
+	  if (!plugin) {
+	    return null;
+	  }
+
+	  return [plugin, r[2]];
+	}
+
+	async function defaultRead$1() {
+	  return undefined;
+	}
+
+	async function defaultWrite$1() {
+	  return false;
+	}
+
+	function initSettings({
+	  read = defaultRead$1,
+	  write = defaultWrite$1
+	} = {}, plugins) {
+	  async function readSetting(path) {
+	    const ret = await read(path);
+
+	    if (ret) {
+	      return ret;
+	    }
+
+	    const p = getPluginPath(path, plugins);
+
+	    if (!p) {
+	      return null;
+	    }
+
+	    const [plugin, pluginPath] = p;
+	    return plugin.readSettings(pluginPath);
+	  }
+
+	  function writeSetting(path, cfg) {
+	    return write(path, cfg);
+	  }
+
+	  return Interface({
+	    read: readSetting,
+	    write: writeSetting
+	  }, {});
+	}
+
+	async function defaultRead() {
+	  return null;
+	}
+
+	async function defaultWrite() {
+	  return false;
+	}
+
+	function initAssets({
+	  read = defaultRead,
+	  write = defaultWrite,
+	  delete: unlink = defaultWrite,
+	  stat = defaultRead
+	} = {}, plugins) {
+	  async function readAsset(path, encoding) {
+	    const ret = await read(path, encoding);
+
+	    if (ret !== null) {
+	      return ret;
+	    }
+
+	    const p = getPluginPath(path, plugins);
+
+	    if (!p) {
+	      return null;
+	    }
+
+	    const [plugin, pluginPath] = p;
+	    return plugin.readAsset(pluginPath, encoding);
+	  }
+
+	  function writeAsset(path, data) {
+	    return write(path, data);
+	  }
+
+	  function deleteAsset(path) {
+	    return unlink(path);
+	  }
+
+	  async function statAsset(path) {
+	    return stat(path);
+	  }
+
+	  return Interface({
+	    read: readAsset,
+	    write: writeAsset,
+	    delete: deleteAsset,
+	    stat: statAsset
+	  }, {});
+	}
+
+	class App extends Router {
+	  /** 连接的处理函数 */
+
+	  /** 设置接口 */
+
+	  /** 资产接口 */
+
+	  /** 日志接口 */
+	  constructor({
+	    router,
+	    settingApi,
+	    assetApi,
+	    logApi,
+	    path
+	  } = {}, plugins = Object.create(null)) {
+	    super(path);
+	    this.settings = initSettings(settingApi, plugins);
+	    this.assets = initAssets(assetApi, plugins);
+	    this.logs = initLog(logApi);
+	    this.plugins = plugins;
+
+	    for (const plugin of Object.values(plugins)) {
+	      this.route(plugin.router);
+	    }
+
+	    if (router instanceof Router) {
+	      this.route(router);
+	    }
+
+	    this.request = callback.bind(this);
+	  }
+
+	}
+
+	function set(handle, key, value) {
+	  if (value === undefined) {
+	    delete handle[key];
+	  }
+
+	  handle[key] = value;
+	  return handle;
+	}
+	/** 设置配置 */
+
+
+	function setTest(test) {
+	  return h => set(h, testSymbol, test);
+	}
+	/** 设置方法 */
+
+	function setMethods(...methods) {
+	  return h => set(h, methodsSymbol, methods.length ? methods : undefined);
+	}
+	/** 设置选项 */
+
+	function setOptions(options) {
+	  return h => set(h, optionsSymbol, options);
+	}
+
+	exports.App = App;
+	exports.Controller = Controller$1;
+	exports.ExitSignal = ExitSignal;
+	exports.Guard = Guard$1;
+	exports.Handle = Handle;
+	exports.Plugin = Plugin;
+	exports.Router = Router;
+	exports.Service = Service$1;
+	exports.catchSymbol = catchSymbol;
+	exports.dataSymbol = dataSymbol;
+	exports.finallySymbol = finallySymbol;
+	exports.initSymbol = initSymbol;
+	exports.methodsSymbol = methodsSymbol;
+	exports.optionsSymbol = optionsSymbol;
+	exports.returnSymbol = returnSymbol;
+	exports.setMethods = setMethods;
+	exports.setOptions = setOptions;
+	exports.setTest = setTest;
+	exports.testSymbol = testSymbol;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));