k99 0.2.0 → 0.3.0-beta.1

package/dist/k99.esm.js

@@ -0,0 +1,3082 @@
+/*!
+ * k99 v0.3.0-beta.1
+ * (c) 2019-2022 Fierflame
+ * @license MIT
+ */
+/**
+ * 服务
+ */
+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;
+}
+/** 处理函数定义 */
+
+let Log;
+
+(function (_Log) {})(Log || (Log = {}));
+
+let Settings;
+
+(function (_Settings) {})(Settings || (Settings = {}));
+
+let Assets;
+
+(function (_Assets) {})(Assets || (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);
+}
+
+export { App, Assets, Controller$1 as Controller, ExitSignal, Guard$1 as Guard, Handle, Log, Plugin, Router, Service$1 as Service, Settings, catchSymbol, dataSymbol, finallySymbol, initSymbol, methodsSymbol, optionsSymbol, returnSymbol, setMethods, setOptions, setTest, testSymbol };