k99 0.6.0-alpha.8 → 0.6.0-beta.0

package/index.cjs

@@ -1,1907 +1,1334 @@
 /*!
- * k99 v0.6.0-alpha.8
- * (c) 2019-2023 猛火Fierflame
+ * k99 v0.6.0-beta.0
+ * (c) 2019-2024 猛火Fierflame
  * @license MIT
  */
 'use strict';
 
+/**
+ * 
+ * @param {string} str 
+ * @returns {Uint8Array}
+ */
 function str2utf8bin(str) {
-  let out = [];
-  let i = 0;
-  for (; i < str.length; i++) {
-    const c = str.codePointAt(i);
-    if (typeof c !== 'number') {
-      break;
-    }
-    if (c >= 0x10000) {
-      i++;
-    }
-    if (c < 0x80) {
-      out.push(c);
-    } else if (c < 0x800) {
-      // 11 = 5 + 6
-      out.push(0xC0 | 0x1F & c >> 6);
-      out.push(0x80 | 0x3F & c);
-    } else if (c < 0x10000) {
-      // 16 = 4 + 6 * 2
-      out.push(0xE0 | 0x0F & c >> 12);
-      out.push(0x80 | 0x3F & c >> 6);
-      out.push(0x80 | 0x3F & c);
-    } else {
-      // 21 = 3 + 6 * 3
-      out.push(0xF0 | 0x07 & c >> 18);
-      out.push(0x80 | 0x3F & c >> 12);
-      out.push(0x80 | 0x3F & c >> 6);
-      out.push(0x80 | 0x3F & c);
-    }
-  }
-  return new Uint8Array(out);
-}
-let base64chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-function base2bin(str, chars = base64chars$1) {
-  const n = Math.floor(Math.log2(chars.length));
-  str = str.replace(/[=\s]+/g, '');
-  let list = new Uint8Array(str.length * n >> 3);
-  let next = 0;
-  let v = 0,
-    l = 0;
-  for (let c of str) {
-    v = v << n | chars.indexOf(c);
-    l += n;
-    while (l >= 8) {
-      l -= 8;
-      list[next++] = v >> l & 0xff;
-      v &= (1 << l) - 1;
-    }
-  }
-  return list;
-}
-let hexChars$1 = '0123456789ABCDEF';
-function hex2bin(str) {
-  let list = [];
-  for (let i = 0; i < str.length; i += 2) {
-    list.push(hexChars$1.indexOf(str[i]) * 16 + hexChars$1.indexOf(str[i + 1] || '0'));
-  }
-  return new Uint8Array(list);
-}
-function str2bin(value, encoding) {
-  if (ArrayBuffer.isView(value)) {
-    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-  }
-  if (value instanceof ArrayBuffer) {
-    return new Uint8Array(value);
-  }
-  if (typeof value !== 'string') {
-    return null;
-  }
-  switch (encoding) {
-    default:
-    case 'utf8':
-      return str2utf8bin(value);
-    case 'base64':
-      return base2bin(value);
-    case 'hex':
-      return hex2bin(value);
-  }
+	return new TextEncoder().encode(str);
 }
+/**
+ * 
+ * @param {unknown} chunk 
+ * @returns {chunk is ArrayBuffer | SharedArrayBuffer}
+ */
+function isBufferSource(chunk) {
+	if (chunk instanceof ArrayBuffer) { return true; }
+	try {
+		if (chunk instanceof SharedArrayBuffer) { return true; }
+	} catch {
 
-function mergeArrayBuffer(data, length) {
-  if (data.length === 1) {
-    return new Uint8Array(data[0]);
-  }
-  const array = new Uint8Array(length);
-  let offset = 0;
-  for (const b of data) {
-    array.set(b, offset);
-    offset += b.byteLength;
-  }
-  return array;
-}
-function getBuffer(data, size) {
-  if (!size) {
-    const ret = mergeArrayBuffer(data, data.reduce((a, b) => a + b.byteLength, 0));
-    data.length = 0;
-    return ret;
-  }
-  let length = 0;
-  const list = [];
-  // eslint-disable-next-line no-cond-assign
-  for (let it; it = data.shift();) {
-    if (length + it.byteLength > size) {
-      const buffer = it.slice(0, size - length);
-      list.push(buffer);
-      length += buffer.byteLength;
-      data.unshift(it.slice(buffer.byteLength));
-      break;
-    }
-    list.push(it);
-    length += it.byteLength;
-    if (length === size) {
-      break;
-    }
-  }
-  return mergeArrayBuffer(list, length);
-}
-async function* toAsyncIterable(chunk) {
-  if (!chunk) {
-    return;
-  }
-  if (typeof chunk === 'string') {
-    return yield str2bin(chunk);
-  }
-  if (typeof chunk !== 'object') {
-    return;
-  }
-  if (chunk instanceof ArrayBuffer) {
-    return yield str2bin(chunk);
-  }
-  if (ArrayBuffer.isView(chunk)) {
-    return yield str2bin(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, cb] = await getNext();
-  for await (const buffer of toAsyncIterable(req)) {
-    data.push(buffer);
-    length += buffer.byteLength;
-    if (size <= 0) {
-      length = 0;
-      cb(getBuffer(data));
-      [size, cb] = await getNext();
-      continue;
-    }
-    if (length >= size) {
-      length -= size;
-      cb(getBuffer(data, size));
-      [size, cb] = await getNext();
-    }
-    while (length && (size <= 0 || size <= length)) {
-      if (size <= 0) {
-        length = 0;
-        cb(getBuffer(data));
-        [size, cb] = await getNext();
-        break;
-      }
-      length -= size;
-      cb(getBuffer(data, size));
-      [size, cb] = await getNext();
-    }
-  }
-  if (length) {
-    cb(getBuffer(data));
-    [size, cb] = await getNext();
-  }
-  cb(null);
-  for (;;) {
-    [size, cb] = await getNext();
-    cb(null);
-  }
-}
-function createRead$1(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) {
-    return new Promise(resolve => {
-      size = Math.max(size, 0);
-      if (next) {
-        next([size, resolve]);
-        return;
-      }
-      list.push([size, 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,
-  signal,
-  body,
-  headers = {}
-}) {
-  const [pathname, search] = parseUrl(path);
-  return {
-    method,
-    url: `${pathname}${search}`,
-    headers,
-    pathname,
-    search,
-    signal: signal || new AbortController().signal,
-    query: parseQuery(search.substring(1)),
-    read: typeof body === 'function' ? body : createRead$1(body)
-  };
+	}
+	return false;
 }
+/**
+ * 
+ * @template T
+ * @param {any} result 
+ * @returns {result is Iterable<T> | AsyncIterable<T>}
+ */
+function isIterable(result) {
+	return Symbol.asyncIterator in result || Symbol.iterator in result;
 
-function isBaseWriteType(chunk) {
-  if (chunk instanceof ArrayBuffer) {
-    return true;
-  }
-  if (ArrayBuffer.isView(chunk)) {
-    return true;
-  }
-  return false;
 }
-function createWrite() {
-  let finished = false;
-  let list = [];
-  let next = null;
-  function done(callback) {
-    if (finished) {
-      return null;
-    }
-    finished = true;
-    if (callback) {
-      callback(false);
-    }
-    // eslint-disable-next-line no-cond-assign
-    for (let value; value = list.shift();) {
-      const [, cb] = value;
-      cb(false);
-    }
-    return null;
-  }
-  let nextPromise = Promise.resolve(() => {});
-  const readable = {
-    next() {
-      const promise = nextPromise.then(cb => {
-        if (!cb) {
-          return;
-        }
-        if (abortException) {
-          cb(false);
-          return abortedPromise;
-        }
-        cb(true);
-        return Promise.race([abortedPromise, new Promise(r => {
-          const value = list.shift();
-          if (value) {
-            return r(value);
-          }
-          next = value => {
-            next = null;
-            r(value);
-          };
-        }).then(value => {
-          const [data, cb] = value;
-          if (!abortException && data !== undefined) {
-            return value;
-          }
-          cb(!abortException);
-        })]);
-      });
-      nextPromise = promise.then(value => {
-        if (!value) {
-          return null;
-        }
-        const [, cb] = value;
-        return cb;
-      }, () => done());
-      return promise.then(value => {
-        if (!value) {
-          return {
-            done: true,
-            value: undefined
-          };
-        }
-        const [data, cb] = value;
-        return {
-          done: false,
-          value: data
-        };
-      });
-    },
-    throw(e) {
-      nextPromise = nextPromise.then(done);
-      return nextPromise.then(() => Promise.reject(e));
-    },
-    return(r) {
-      nextPromise = nextPromise.then(done);
-      return nextPromise.then(() => r);
-    },
-    [Symbol.asyncIterator]() {
-      return readable;
-    }
-  };
-  let abortException;
-  let abortReject;
-  let abortedPromise = new Promise((_, reject) => {
-    if (abortException) {
-      reject(abortException);
-    } else {
-      abortReject = reject;
-    }
-  });
-  function abort(e) {
-    if (abortException) {
-      return false;
-    }
-    abortException = e || new DOMException('The user aborted a request.');
-    if (abortReject) {
-      abortReject(abortException);
-    }
-    return true;
-  }
-  function run(chunk, cb) {
-    if (finished) {
-      return cb(false);
-    }
-    if (!next) {
-      list.push([chunk, cb]);
-      return;
-    }
-    next([chunk, cb]);
-  }
-  let writePromise = Promise.resolve(true);
-  /**
-   * 向可写流中写入数据
-   * @param chunk 要写入的数据
-   */
-  async function write(chunk) {
-    if (finished) {
-      return Promise.resolve();
-    }
-    if (typeof chunk === 'string') {
-      return new Promise(cb => run(str2bin(chunk), cb));
-    }
-    if (typeof chunk !== 'object') {
-      return false;
-    }
-    if (isBaseWriteType(chunk)) {
-      return new Promise(cb => run(str2bin(chunk), cb));
-    }
-    if (!(Symbol.asyncIterator in chunk || Symbol.iterator in chunk)) {
-      return false;
-    }
-    for await (const data of chunk) {
-      if (finished) {
-        return Promise.resolve();
-      }
-      if (data && !(await write(data))) {
-        return false;
-      }
-    }
-    return true;
-  }
-  let ended = false;
-  const writable = {
-    write(chunk) {
-      const promise = writePromise.then(v => {
-        if (v === undefined) {
-          return;
-        }
-        if (!chunk) {
-          return true;
-        }
-        return write(chunk);
-      });
-      writePromise = promise;
-      return promise.then(v => Boolean(v));
-    },
-    end() {
-      ended = true;
-      const promise = writePromise.then(v => new Promise(cb => {
-        if (v === undefined || finished) {
-          return cb();
-        }
-        if (!next) {
-          list.push([undefined, () => cb()]);
-          return;
-        }
-        next([undefined, () => cb()]);
-      }));
-      writePromise = promise;
-      return promise;
-    },
-    get ended() {
-      return finished || ended;
-    }
-  };
-  return [writable, readable, abort];
+/**
+ * 向可写流中写入数据
+ * @param {WritableStreamDefaultWriter<Uint8Array>} writer 
+ * @param {unknown} chunk 要写入的数据
+ * @returns {Promise<void>}
+ */
+async function write(writer, chunk) {
+	if (typeof chunk === 'string') {
+		return writer.write(str2utf8bin(chunk));
+	}
+	if (typeof chunk !== 'object') { return; }
+	if (ArrayBuffer.isView(chunk)) {
+		return writer.write(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+	}
+	if (isBufferSource(chunk)) {
+		return writer.write(new Uint8Array(chunk));
+	}
+	if (!isIterable(chunk)) {
+		return;
+	}
+	for await (const data of chunk) {
+		if (!data) { continue; }
+		await write(writer, data);
+	}
 }
 
-function* getCookie(sentCookies, name) {
-  const list = sentCookies;
-  for (const item of list) {
-    if (name && item.name !== name) {
-      continue;
-    }
-    yield {
-      ...item
-    };
-  }
-}
-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);
-}
-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 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
-        });
-      }
-    }
-  }
+/**
+ * 
+ * @param {any} k 
+ * @param {any} v 
+ * @returns {any}
+ */
+function replacer(k, v) {
+	if (typeof v === 'bigint') {
+		return String(v);
+	}
+	return v;
 }
 
-function utf8bin2str(code) {
-  let ret = [];
-  let index = 0;
-  while (index < code.length) {
-    let c = code[index++] | 0;
-    if (c >= 0b11110000) {
-      c = (c & 0x7) << 18;
-      c |= (code[index++] & 0x3F) << 12;
-      c |= (code[index++] & 0x3F) << 6;
-      c |= code[index++] & 0x3F;
-    } else if (c >= 0b11100000) {
-      c = (c & 0xF) << 12;
-      c |= (code[index++] & 0x3F) << 6;
-      c |= code[index++] & 0x3F;
-    } else if (c >= 0b11000000) {
-      c = (c & 0x1F) << 6;
-      c |= code[index++] & 0x3F;
-    }
-    ret.push(c);
-  }
-  return ret.map(x => String.fromCharCode(x)).join('');
-}
-let base64chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-function bin2base(buff, chars = base64chars) {
-  const n = Math.floor(Math.log2(chars.length));
-  const mask = (1 << n) - 1;
-  let list = new Array(Math.floor(((buff.byteLength << 3) + n - 1) / n));
-  let next = 0;
-  let v = 0,
-    l = 0;
-  for (let b of buff) {
-    v = v << 8 | b;
-    l += 8;
-    while (l >= n) {
-      l -= n;
-      list[next++] = chars[v >> l & mask];
-      v &= (1 << l) - 1;
-    }
-  }
-  if (l) {
-    list[next++] = chars[v << n - l & mask];
-  }
-  while (list.length % 4) {
-    list.push('=');
-  }
-  return list.join('');
-}
-let hexChars = '0123456789ABCDEF';
-function bin2hex(buff) {
-  let list = new Array(buff.byteLength * 2);
-  for (let b of buff) {
-    list.push(b >> 4 & 0x1111, b & 0x1111);
-  }
-  return list.map(v => hexChars[v]).join('');
-}
-function bin2str(value, encoding) {
-  if (!value) {
-    return null;
-  }
-  switch (encoding) {
-    case 'utf8':
-      return utf8bin2str(value);
-    case 'base64':
-      return bin2base(value);
-    case 'hex':
-      return bin2hex(value);
-  }
-  return value;
+/**
+ * 
+ * @param {any} result 
+ * @param {Promise<never>} [aborted] 
+ * @returns {[BodyInit, number, string] | null}
+ */
+function toBodyData(result, aborted) {
+	if (result instanceof ReadableStream) {
+		return [result, 0, ''];
+	}
+	if (result instanceof URLSearchParams) {
+		return [result, 0, ''];
+	}
+	if (result instanceof Blob) {
+		return [result, result.size, result.type];
+	}
+	if (result instanceof FormData) {
+		return [result, 0, ''];
+	}
+	if (ArrayBuffer.isView(result) || isBufferSource(result)) {
+		return [result, result.byteLength, ''];
+	}
+	if (typeof result === 'string') {
+		const body = str2utf8bin(result);
+		return [body, body.byteLength, ''];
+	}
+	if (typeof result !== 'object') {
+		return null;
+	}
+	if (Array.isArray(result) || !isIterable(result)) {
+		const body = str2utf8bin(JSON.stringify(result, replacer));
+		return [body, body.byteLength, 'application/json'];
+	}
+	/** @type {TransformStream<Uint8Array, Uint8Array>} */
+	const { writable, readable } = new TransformStream();
+	const writer = writable.getWriter();
+	aborted?.catch((e) => {
+		writable.abort(e || new DOMException('The user aborted a request.')).catch(() => {});
+	});
+	(async () => {
+		for await (const data of result) {
+			if (!data) { continue; }
+			await write(writer, data);
+		}
+		await writable.close();
+	})().catch(() => {});
+	return [readable, 0, ''];
 }
-
-function createRead(get) {
-  let readPromise = Promise.resolve(false);
-  function read(size = 0, encoding) {
-    const promise = readPromise.then(v => {
-      if (v) {
-        return null;
-      }
-      return get(size);
-    });
-    readPromise = promise.then(v => !v);
-    return promise.then(value => bin2str(value, encoding));
-  }
-  return read;
+/**
+ * 
+ * @param {any} result 
+ * @param {Headers} headers 
+ * @param {Promise<never>} [aborted] 
+ * @returns 
+ */
+function toBody(result, headers, aborted) {
+	const bodyData = toBodyData(result, aborted);
+	if (!bodyData) { return null; }
+	const [body, size, type] = bodyData;
+	if (type && !headers.get('Content-Type')) {
+		headers.set('Content-Type', type);
+	}
+	if (size > 0 && !headers.get('Content-Length')) {
+		headers.set('Content-Length', String(size));
+	}
+	return body;
 }
 
-function destroyServices(services, environment) {
-  let promise = Promise.resolve();
-  for (const [service, context] of [...services.entries()]) {
-    promise = promise.then(() => service(Object.create(context, {
-      destroying: {
-        value: true,
-        configurable: true,
-        enumerable: true
-      }
-    }))).catch(e => environment?.error?.(e));
-  }
-  return promise;
-}
-const hostRegex = /^(\[[^\]]+\]|^:):(\d+)$/;
-function createContext({
-  method,
-  url,
-  pathname,
-  search,
-  query,
-  read,
-  headers,
-  signal
-}, request, environment, parent) {
-  const services = new Map();
-  const host = headers.host || '';
-  const hostInfo = hostRegex.exec(host);
-  const [hostname, port] = hostInfo ? [hostInfo[1], hostInfo[2]] : [host, ''];
-  const cookies = getRequestCookies(headers['cookie'] || '');
-  const sentCookies = [];
-  let status = 200;
-  let resHeaders = {};
-  let headersSent = false;
-  let destroyed = false;
-  const root = parent?.root;
-  let hasError = null;
-  let params = {};
-  const context = {
-    environment,
-    parent,
-    get error() {
-      return hasError;
-    },
-    get root() {
-      return root || this;
-    },
-    signal,
-    request,
-    service(service, ...p) {
-      if (service.rootOnly && root) {
-        return root.service(service, ...p);
-      }
-      let serviceContext = services.get(service);
-      if (!serviceContext) {
-        let state;
-        serviceContext = Object.create(context, {
-          destroying: {
-            value: false,
-            configurable: true,
-            enumerable: true
-          },
-          currentService: {
-            value: service,
-            configurable: true,
-            enumerable: true
-          },
-          state: {
-            configurable: true,
-            enumerable: true,
-            get() {
-              return state;
-            },
-            set(s) {
-              state = s;
-            }
-          }
-        });
-        services.set(service, serviceContext);
-      }
-      return service(serviceContext, ...p);
-    },
-    method,
-    url,
-    pathname,
-    search,
-    query,
-    get params() {
-      return params;
-    },
-    headers: Object.freeze({
-      ...headers
-    }),
-    host,
-    hostname,
-    port,
-    requestType: headers['content-type'] || '',
-    referer: headers.referer || '',
-    userAgent: headers['user-agent'] || '',
-    accept: (headers.accept || '').split(/,\s*/).filter(Boolean),
-    acceptLanguage: (headers['accept-language'] || '').split(/,\s*/).filter(Boolean),
-    cookies,
-    read: createRead(read),
-    get destroyed() {
-      return destroyed;
-    },
-    get headersSent() {
-      return headersSent;
-    },
-    get status() {
-      return status;
-    },
-    set status(v) {
-      if (headersSent) {
-        return;
-      }
-      status = v;
-    },
-    get location() {
-      return resHeaders['location'] || '';
-    },
-    set location(url) {
-      if (!headersSent) {
-        resHeaders['location'] = url;
-      }
-    },
-    get responseType() {
-      return resHeaders['content-type'] || '';
-    },
-    set responseType(v) {
-      if (!headersSent) {
-        resHeaders['content-type'] = v;
-      }
-    },
-    getCookie(name) {
-      return getCookie(sentCookies, name);
-    },
-    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);
-    },
-    hasHeader(n) {
-      return n in resHeaders;
-    },
-    getHeaderNames() {
-      return Object.keys(resHeaders);
-    },
-    getHeaders() {
-      return {
-        ...resHeaders
-      };
-    },
-    getHeader(n) {
-      return resHeaders[n];
-    },
-    setHeader(n, v) {
-      if (headersSent) {
-        return;
-      }
-      if (v === undefined) {
-        delete resHeaders[n];
-      } else {
-        resHeaders[n] = v;
-      }
-    }
-  };
-  return {
-    context,
-    setParams: v => {
-      params = v;
-    },
-    destroy: error => {
-      if (destroyed) {
-        return;
-      }
-      destroyed = true;
-      headersSent = true;
-      if (error) {
-        hasError = error;
-      }
-      destroyServices(services, environment);
-    },
-    sendHeaders() {
-      if (headersSent) {
-        return false;
-      }
-      headersSent = true;
-      return true;
-    }
-  };
+/**
+ * 
+ * @param {import('./types').Cookie[]} sentCookies 
+ * @param {string} [name] 
+ * @returns {Iterable<import('./types').Cookie>}
+ */
+function *getCookie(sentCookies, name) {
+	const list = sentCookies;
+	for (const item of list) {
+		if (name && item.name !== name) { continue; }
+		yield { ...item };
+	}
 }
 
-function isJSON(result) {
-  if (!result) {
-    return false;
-  }
-  if (typeof result !== 'object') {
-    return false;
-  }
-  if (Array.isArray(result)) {
-    return true;
-  }
-  if (isBaseWriteType(result)) {
-    return false;
-  }
-  if (Symbol.asyncIterator in result || Symbol.iterator in result) {
-    return false;
-  }
-  return true;
-}
-function replacer(k, v) {
-  if (typeof v === 'bigint') {
-    return String(v);
-  }
-  return v;
+/**
+ * 
+ * @param {Headers} headers 
+ * @param {import('./types').Cookie[]} cookies 
+ * @returns {void}
+ */
+function setCookiesHeader(headers, cookies) {
+	headers.delete('set-cookie');
+	for (const { name, value, expire, domain, path, secure, httpOnly } of cookies) {
+		if (!name) { continue; }
+		headers.append('set-cookie', [
+			`${ encodeURI(name) }=${ encodeURI(value || '') }`,
+			expire && `Expires=${ expire }`,
+			domain && `Domain=${ encodeURI(domain) }`,
+			path && `Path=${ encodeURI(path) }`,
+			secure && 'Secure',
+			httpOnly && 'HttpOnly',
+		].filter(Boolean).join('; '));
+	}
 }
-async function runHandle(context, handle) {
-  if (context.headersSent) {
-    return;
-  }
-  const result = await handle(context);
-  if (context.finished) {
-    return;
-  }
-  if (isJSON(result)) {
-    if (context.headersSent) {
-      return;
-    }
-    context.responseType = 'application/json';
-    await context.write(JSON.stringify(result, replacer));
-    return;
-  }
-  return context.write(result);
+/**
+ * 
+ * @param {string} cookie 
+ * @returns {Record<string, string>}
+ */
+function getRequestCookies(cookie) {
+	/** @type {{ [key: string]: string; }} */
+	let cookies = {};
+	for (const item of cookie.replace(/\s/g, '').split(';')) {
+		const v = item.split('=');
+		const name = decodeURIComponent(/** @type {string} */(v.shift()));
+		cookies[name] = decodeURIComponent(v.join('='));
+	}
+	return cookies;
 }
+/**
+ * 
+ * @param {import('./types').Cookie[]} sentCookies 
+ * @param {Record<string, string>} cookies 
+ * @param {string | import('./types').CookieOption} [name] 
+ * @param {import('./types').CookieOption | boolean} [opt] 
+ * @returns {void}
+ */
+function clearCookie(
+	sentCookies,
+	cookies,
+	name,
+	opt,
+) {
+	let expire = 'Fri, 31 Dec 1999 16:00:00 GMT';
+	if (typeof name === 'string') {
+		if (!name) { return; }
+		/** @type {import('./types').CookieOption} */
+		const { domain, path, secure, httpOnly } = opt !== true && opt || {};
+		sentCookies.push({ name, value: 'delete', expire, domain, path, secure, httpOnly });
+	} else {
+		/** @type {import('./types').CookieOption} */
+		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 });
+			}
+		}
+	}
+}
+
+const noBodyMethods = new Set(['GET', 'OPTIONS']);
+/**
+ * 
+ * @param {AbortSignal} signal 
+ * @returns {Promise<never>}
+ */
 function signal2promise(signal) {
-  return new Promise((_, reject) => {
-    if (signal.aborted) {
-      return reject(signal.reason);
-    }
-    signal.addEventListener('abort', () => reject(signal.reason), {
-      once: true
-    });
-  });
-}
-function main(req, getHandler, environment, runner, parent) {
-  const aborted = signal2promise(req.signal);
-  const {
-    context,
-    setParams,
-    destroy,
-    sendHeaders
-  } = createContext(req, opt => main(createRequest(opt), getHandler, environment, runner, context), environment, parent);
-  function run() {
-    return Promise.race([aborted, Promise.resolve().then(() => getHandler(context, setParams))]).then(handler => new Promise(resolve => {
-      if (!handler) {
-        destroy();
-        return resolve(null);
-      }
-      const [writable, readable, abortResponse] = createWrite();
-      aborted.catch(e => abortResponse(e));
-      function send() {
-        if (!sendHeaders()) {
-          return;
-        }
-        const {
-          status
-        } = context;
-        resolve({
-          ...readable,
-          get status() {
-            return status;
-          },
-          get finished() {
-            return writable.ended;
-          },
-          headers: Object.freeze(context.getHeaders()),
-          [Symbol.asyncIterator]() {
-            return readable;
-          }
-        });
-      }
-      const contextS = {
-        get finished() {
-          return writable.ended;
-        },
-        write(chunk) {
-          send();
-          return writable.write(chunk);
-        }
-      };
-      const actionContext = Object.create(context, Object.getOwnPropertyDescriptors(contextS));
-      Promise.race([aborted, runHandle(actionContext, handler)]).then(() => {
-        send();
-        destroy();
-        writable.end();
-      }, e => {
-        context.status = 500;
-        send();
-        abortResponse(e);
-        destroy(e || true);
-        writable.end();
-      });
-    }), e => {
-      destroy(e || true);
-      return Promise.reject(e);
-    });
-  }
-  return runner ? runner(context, run) : run();
-}
-
-async function defaultRead$2() {
-  return undefined;
-}
-async function defaultWrite$2() {
-  return false;
-}
-function initSettings({
-  read = defaultRead$2,
-  write = defaultWrite$2
-} = {}) {
-  return {
-    read,
-    write
-  };
-}
-
-async function defaultRead$1() {
-  return null;
-}
-async function defaultWrite$1() {
-  return false;
-}
-function initAssets({
-  read = defaultRead$1,
-  write = defaultWrite$1,
-  delete: unlink = defaultWrite$1,
-  stat = defaultRead$1
-} = {}) {
-  async function readAsset(path, encoding) {
-    const ret = await read(path);
-    return ret && bin2str(ret, encoding);
-  }
-  async function writeAsset(path, data, encoding) {
-    if (data === undefined) {
-      return unlink(path);
-    }
-    const value = str2bin(data, encoding);
-    if (!value) {
-      return unlink(path);
-    }
-    return write(path, value);
-  }
-  function deleteAsset(path) {
-    return unlink(path);
-  }
-  async function statAsset(path) {
-    return stat(path);
-  }
-  return {
-    read: readAsset,
-    write: writeAsset,
-    delete: deleteAsset,
-    stat: statAsset
-  };
+	return new Promise((_, reject) => {
+		if (signal.aborted) {
+			return reject(signal.reason);
+		}
+		signal.addEventListener(
+			'abort',
+			() => reject(signal.reason),
+			{ once: true }
+		);
+	});
 }
 
 /**
- * 包装日志文本
- * @param log 原始的日志
- * @param opt 包装选项
+ * 
+ * @param {Headers} headers 
+ * @param {string} name 
+ * @param {string} [value] 
  */
-function pack(log, {
-  tags,
-  indent,
-  date
-} = {}) {
-  let extendInfo = '';
-  if (tags) {
-    if (!Array.isArray(tags)) {
-      tags = [tags];
-    }
-    extendInfo = tags.map(tag => `[${tag}]`).join(' ');
-  }
-  if (date) {
-    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 regex$2 = /(?:^|\/)(debug|error|warn|info)\/?$|^\/?(debug|error|warn|info)(?:\/|$)/;
-async function defaultWrite(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;
-  }
-  console.group(`log @ ${path}`);
-  const v = regex$2.exec(path);
-  switch (v ? v[1] || v[2] : '') {
-    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();
-  return true;
-}
-async function defaultRead() {
-  return '';
+function setHeader(headers, name, value) {
+	if (value) {
+		headers.set(name, value);
+	} else {
+		headers.delete(name);
+	}
 }
-async function defaultClear() {}
-function initLog({
-  read = defaultRead,
-  write = defaultWrite,
-  clear = defaultClear
-} = {}) {
-  function writeLog(path, log, opt) {
-    return write(path, pack(log, opt));
-  }
-  return {
-    read,
-    write: writeLog,
-    clear,
-    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);
-    }
-  };
-}
-
-function createEnvironment(options) {
-  const asset = initAssets(options?.asset);
-  const setting = initSettings(options?.setting);
-  const log = initLog(options?.log);
-  return {
-    asset,
-    setting,
-    log,
-    error: options?.error || (e => {
-      log.error(e);
-    })
-  };
+/**
+ * 
+ * @param {Request} request 
+ * @param {string | ((request: Request) => string)} [toMethod] 
+ * @returns {import('./types').Method}
+ */
+function getMethod(request, toMethod) {
+	let methodStr = '';
+	if (typeof toMethod === 'string') {
+		methodStr = toMethod;
+	} else if (typeof toMethod === 'function') {
+		methodStr = toMethod(request);
+	}
+	if (!methodStr || typeof methodStr !== 'string') {
+		methodStr = request.method || 'GET';
+	}
+	return /** @type {import('./types').Method} */(methodStr.toUpperCase());
 }
-
-function run(req, getHandler, options) {
-  const environment = createEnvironment(options);
-  return main(req, getHandler, environment, options?.runner);
+/**
+ * 
+ * @param {Request} request 
+ * @param {import('./types').FindHandler} getHandler 
+ * @param {import('./types').Options} [options]
+ * @returns {Promise<Response | null>}
+ */
+function main(
+	request, getHandler,
+	{ runner, error: echoError, method: toMethod, environment } = {},
+) {
+	/**
+	 * 
+	 * @param {Request} request 
+	 * @param {import('./types').Context} [parent] 
+	 * @returns {Promise<Response | null>}
+	 */
+	function exec(request, parent) {
+		const method = getMethod(request, toMethod);
+		const url = new URL(request.url);
+		const { signal, headers } = request;
+		const aborted = signal2promise(signal);
+		/** @type {Map<import('./types').Service<any, any>, Function>} */
+		const services = new Map();
+		const cookies = getRequestCookies(headers.get('cookie') || '');
+		/** @type {import('./types').Cookie[]} */
+		const sentCookies = [];
+		const responseHeaders = new Headers();
+		const root = parent?.root;
+		let status = 200;
+		let destroyed = false;
+		/** @type {any} */
+		let error = null;
+
+		let resolve = () => {};
+		/** @type {(error: unknown) => void} */
+		let reject = (error) => {};
+		/** @type {Promise<void>} */
+		const donePromise = new Promise((a, b) => { resolve = a; reject = b; });
+		donePromise.catch(() => {});
+
+		/** @type {any} */
+		let params = {};
+		/** @type {import('./types').Context} */
+		const context = {
+			environment,
+			parent,
+			get error() { return error; },
+			get root() { return root || this; },
+			signal,
+			url,
+			fetch(input, { method = 'get', signal, body: data, headers: h } = {}) {
+				const fetchUrl = new URL(input, url);
+				const headers = new Headers(h || {});
+				if (!data || noBodyMethods.has(method.toUpperCase())) {
+					return exec(new Request(fetchUrl, { method, headers, signal }), context);
+				}
+				const body = toBody(data, headers);
+				return exec(new Request(fetchUrl, { method, headers, signal, body }), context);
+			},
+			done(onfulfilled, onrejected) {
+				if (destroyed) { return null; }
+				const result = donePromise.then(onfulfilled, onrejected);
+				result.catch(echoError);
+				return result;
+			},
+			service(service, ...p) {
+				if (service.rootOnly && root) {
+					return root.service(service, ...p);
+				}
+				let fn = services.get(service);
+				if (!fn) {
+					fn = service(context);
+					if (typeof fn !== 'function') { return; }
+					services.set(service, fn);
+				}
+				return fn(...p);
+			},
+
+			method,
+			get params() { return params; },
+			requestHeaders: headers,
+			requestType: headers.get('content-type') || '',
+			referer: headers.get('referer') || '',
+			userAgent: headers.get('user-agent') || '',
+			accept: (headers.get('accept') || '').split(/,\s*/).filter(Boolean),
+			acceptLanguage: (headers.get('accept-language') || '')
+				.split(/,\s*/)
+				.filter(Boolean),
+			cookies,
+			request,
+
+			get destroyed() { return destroyed; },
+			get status() { return status; },
+			set status(v) { status = v; },
+			responseHeaders,
+			get location() { return responseHeaders.get('location') || ''; },
+			set location(url) { setHeader(responseHeaders, 'location', url); },
+			get responseType() { return responseHeaders.get('content-type') || ''; },
+			set responseType(type) { setHeader(responseHeaders, 'content-type', type); },
+			getCookie(name) { return getCookie(sentCookies, name); },
+			setCookie(name, value, { expire, domain, path, secure, httpOnly } = {}) {
+				sentCookies.push({name, value, expire, domain, path, secure, httpOnly});
+				setCookiesHeader(responseHeaders, sentCookies);
+			},
+			/**
+			 * 
+			 * @param {string | import('./types').CookieOption} [name] 
+			 * @param {import('./types').CookieOption | boolean} [opt] 
+			 * @returns {void}
+			 */
+			clearCookie(name, opt) {
+				clearCookie(sentCookies, cookies, name, opt);
+				setCookiesHeader(responseHeaders, sentCookies);
+			},
+		};
+		function run() {
+			return Promise.race([
+				aborted,
+				Promise.resolve().then(() => getHandler(context, v => { params = v; })),
+			]).then(handler => handler ? Promise.race([aborted, handler(context)]).then(result => {
+				if (result instanceof Response) {
+					return result;
+				}
+				const headers = new Headers(context.responseHeaders);
+				const { status } = context;
+				if (!result) { return new Response(null, { status, headers }); }
+				const body = toBody(result, headers, aborted);
+				return new Response(body, { status, headers });
+			}) : null).then(response => {
+				destroyed = true;
+				resolve();
+				return response;
+			}, e => {
+				destroyed = true;
+				error = e || true;
+				reject(error);
+				return Promise.reject(e);
+			});
+		}
+		return runner ? runner(context, run) : run();
+	}
+	return exec(request);
 }
 
+/**
+ * 
+ * @param {import('./main/types').FindHandler} getHandler 
+ * @param {import('./main/types').Options} options 
+ * @returns {(request: Request) => Promise<Response | null>}
+ */
 function make(getHandler, options) {
-  const environment = createEnvironment(options);
-  return r => main(r, getHandler, environment, options?.runner);
+	return (r) => main(r, getHandler, options);
 }
 
+/**
+ * 
+ * @param {import('./main/types').Context} context 
+ * @param {import('./main/types').Handler[]} handlers 
+ * @returns {Promise<string | boolean | object | undefined>}
+ */
 async function runHandles(context, handlers) {
-  for (const handle of handlers) {
-    if (context.headersSent) {
-      break;
-    }
-    const result = await handle(context);
-    if (context.finished) {
-      break;
-    }
-    if (typeof result === 'boolean') {
-      return result;
-    }
-    if (!result) {
-      continue;
-    }
-    return result;
-  }
+	for (const handle of handlers) {
+		const result = await handle(context);
+		if (typeof result === 'boolean') { return result; }
+		if (!result) { continue; }
+		return result;
+	}
 }
+
+/**
+ * 
+ * @param  {...(import('./main/types').Handler | import('./main/types').Handler[])} handlers 
+ * @returns {import('./main/types').Handler}
+ */
 function merge(...handlers) {
-  return ctx => runHandles(ctx, handlers.flat());
+	return ctx => runHandles(ctx, handlers.flat());
 }
 
+/**
+ * 
+ * @template T
+ * @template {any[]} P
+ * @overload
+ * @param {(ctx: import('./main/types').Context, ...p: P) => T} exec 
+ * @param {((ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void)?} [destroy] 
+ * @param {import('./main/types').Service.Options?} [options] 
+ * @returns {import('./main/types').Service<T, P>}
+ */
+/**
+ * 
+ * @template T
+ * @template {any[]} P
+ * @overload
+ * @param {(ctx: import('./main/types').Context, ...p: P) => T} exec 
+ * @param {import('./main/types').Service.Options?} [options] 
+ * @returns {import('./main/types').Service<T, P>}
+ */
+/**
+ * @template T
+ * @template {any[]} P
+ * @param {(ctx: import('./main/types').Context, ...p: P) => T} exec 
+ * @param {((ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void) | import('./main/types').Service.Options | null} [destroy] 
+ * @param {import('./main/types').Service.Options?} [options] 
+ * @returns {import('./main/types').Service<T, P>}
+ */
 function service(exec, destroy, options) {
-  const service = function (ctx, ...any) {
-    if (ctx.currentService !== service) {
-      return ctx.service(service, ...any);
-    }
-    if (!ctx.destroying) {
-      return exec(ctx, ...any);
-    }
-    if (typeof destroy === 'function') {
-      return destroy(ctx);
-    }
-  };
-  const {
-    rootOnly
-  } = typeof destroy === 'object' && destroy || typeof options === 'object' && options || {};
-  Object.assign(service, {
-    rootOnly: Boolean(rootOnly)
-  });
-  return service;
+	/** @type {import('./main/types').Service<T, P>} */
+	const service = function (ctx) {
+		if (typeof destroy === 'function') {
+			ctx.done(() => destroy(ctx), error => destroy(ctx, error));
+		}
+		/**
+		 * @param {...any} any
+		 */
+		return (...any) => exec(ctx, ...any);
+	};
+	const {
+		rootOnly,
+	} = typeof destroy === 'object' && destroy
+	|| typeof options === 'object' && options
+		|| {};
+	Object.assign(service, { rootOnly: Boolean(rootOnly) });
+	return service;
 }
 
+/**
+ * 
+ * @template T
+ * @overload
+ * @param {(ctx: import('./main/types').Context) => T} init 
+ * @param {import('./main/types').Service.Options} [options] 
+ * @returns {import('./main/types').StateService<T>}
+ */
+/**
+ * 
+ * @template T
+ * @overload
+ * @param {(ctx: import('./main/types').Context) => T} init 
+ * @param {((state: T | undefined, ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void)?} [destroy] 
+ * @param {import('./main/types').Service.Options?} [options] 
+ * @returns {import('./main/types').StateService<T>}
+ */
+/**
+ * 
+ * @template T
+ * @overload
+ * @param {(ctx: import('./main/types').Context) => T} init 
+ * @param {((state: T | undefined, ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void)?} [destroy] 
+ * @param {((state: T, ctx: import('./main/types').Context) => any)?} [exec] 
+ * @param {import('./main/types').Service.Options?} [options] 
+ * @returns {import('./main/types').StateService<T>}
+ */
+/**
+ * @template T
+ * @param {(ctx: import('./main/types').Context) => T} init 
+ * @param {((state: T | undefined, ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void) | import('./main/types').Service.Options | null} [destroy] 
+ * @param {((state: T, ctx: import('./main/types').Context) => any) | import('./main/types').Service.Options | null} [exec] 
+ * @param {import('./main/types').Service.Options?} [options] 
+ * @returns {import('./main/types').StateService<T>}
+ */
 function stateService(init, destroy, exec, options) {
-  const service = function (ctx) {
-    if (ctx.currentService !== service) {
-      return ctx.service(service);
-    }
-    if (!ctx.destroying) {
-      let {
-        state
-      } = ctx;
-      if (!state) {
-        state = init(ctx) || {};
-        ctx.state = state;
-      }
-      if (typeof exec === 'function') {
-        exec(state, ctx);
-      }
-      return state;
-    }
-    if (typeof destroy === 'function') {
-      return destroy(ctx.state, ctx);
-    }
-  };
-  const {
-    rootOnly
-  } = typeof destroy === 'object' && destroy || typeof exec === 'object' && exec || typeof options === 'object' && options || {};
-  Object.assign(service, {
-    rootOnly: Boolean(rootOnly)
-  });
-  return service;
+	/** @type {import('./main/types').StateService<T>} */
+	const service = function (ctx) {
+		const state = init(ctx) || /** @type {T} */({});
+		if (typeof destroy === 'function') {
+			ctx.done(() => destroy(state, ctx), error => destroy(state, ctx, error));
+		}
+		if (typeof exec !== 'function') {
+			return () => state;
+		}
+		return () => {
+			exec(state, ctx);
+			return state;
+		};
+	};
+	const {
+		rootOnly,
+	} = typeof destroy === 'object' && destroy
+		|| typeof exec === 'object' && exec
+		|| typeof options === 'object' && options
+		|| {};
+	Object.assign(service, { rootOnly: Boolean(rootOnly) });
+	return service;
 }
 
+/**
+ * 
+ * @template T
+ * @overload
+ * @param {import('./main/types').Service.Options?} [options] 
+ * @returns {import('./main/types').StoreService<T>}
+ */
+/**
+ * 
+ * @template T
+ * @overload
+ * @param {((state: T | undefined, ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void)?} [destroy] 
+ * @param {import('./main/types').Service.Options?} [options] 
+ * @returns {import('./main/types').StoreService<T>}
+ */
+/**
+ * 
+ * @template T
+ * @overload
+ * @param {((state: T | undefined, ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void)?} [destroy] 
+ * @param {((state: T | undefined, ctx: import('./main/types').Context) => any)?} [exec] 
+ * @param {import('./main/types').Service.Options?} [options] 
+ * @returns {import('./main/types').StoreService<T>}
+ */
+/**
+ * @template T
+ * @param {((state: T | undefined, ctx: import('./main/types').Context, error?: unknown) => PromiseLike<void> | void) | import('./main/types').Service.Options | null} [destroy] 
+ * @param {((state: T | undefined, ctx: import('./main/types').Context) => any) | import('./main/types').Service.Options | null} [exec] 
+ * @param {import('./main/types').Service.Options?} [options] 
+ * @returns {import('./main/types').StoreService<T>}
+ */
 function storeService(destroy, exec, options) {
-  const service = function (ctx, ...s) {
-    if (ctx.currentService !== service) {
-      return ctx.service(service, ...s);
-    }
-    if (!ctx.destroying) {
-      if (!s.length) {
-        return ctx.state;
-      }
-      const [state] = s;
-      ctx.state = state;
-      if (typeof exec === 'function') {
-        exec(state, ctx);
-      }
-      return state;
-    }
-    if (typeof destroy === 'function') {
-      return destroy(ctx.state, ctx);
-    }
-  };
-  const {
-    rootOnly
-  } = typeof destroy === 'object' && destroy || typeof exec === 'object' && exec || typeof options === 'object' && options || {};
-  Object.assign(service, {
-    rootOnly: Boolean(rootOnly)
-  });
-  return service;
+	/** @type {import('./main/types').StoreService<T>} */
+	const service = function (ctx) {
+		/** @type {T | undefined} */
+		let state;
+		if (typeof destroy === 'function') {
+			ctx.done(() => destroy(state, ctx), error => destroy(state, ctx, error));
+		}
+		if (typeof exec !== 'function') {
+			/**
+			 * @param {[s?: T]} s
+			 */
+			return (...s) => {
+				if (s.length) { [state] = s; }
+				return state;
+			};
+		}
+		/**
+		 * @param {[s?: T]} s
+		 */
+		return (...s) => {
+			if (s.length) {
+				[state] = s;
+				exec(state, ctx);
+			}
+			return state;
+		};
+	};
+	const {
+		rootOnly,
+	} = typeof destroy === 'object' && destroy
+		|| typeof exec === 'object' && exec
+		|| typeof options === 'object' && options
+		|| {};
+	Object.assign(service, { rootOnly: Boolean(rootOnly) });
+	return service;
 }
 
+/**
+ * @callback Guard
+ * @param {import('./main/types').Context} ctx
+ * @returns {PromiseLike<boolean | import('./main/types').Handler | void> | boolean | import('./main/types').Handler | void}
+ */
+
+/**
+ * @typedef {[import('./main/types').Handler | Router, Record<string, any>, string[]]} FindItem
+ */
+/**
+ * @callback Finder
+ * @this {Router}
+ * @property {import('./main/types').Method} method
+ * @property {string[]} path
+ * @returns {AsyncIterable<FindItem> | Iterable<FindItem>}
+ */
+
+/**
+ * 
+ * @param {Set<Guard>} guards 
+ * @param {import('./main/types').Context} ctx 
+ * @param {(v: any) => void} setParams 
+ * @param {object} params 
+ * @returns {Promise<boolean | import('./main/types').Handler>}
+ */
 async function execGuard(guards, ctx, setParams, params) {
-  if (!guards.size) {
-    return true;
-  }
-  setParams(params);
-  for (const guard of guards) {
-    if (ctx.destroyed) {
-      return false;
-    }
-    const ret = await guard(Object.create(ctx, {
-      params: {
-        value: {
-          ...params
-        }
-      }
-    }));
-    if (ret === false) {
-      return false;
-    }
-    if (typeof ret === 'function') {
-      return ret;
-    }
-  }
-  return true;
+	if (!guards.size) { return true; }
+	setParams(params);
+	for (const guard of guards) {
+		if (ctx.destroyed) { return false; }
+		const ret = await guard(Object.create(ctx, {
+			params: { value: { ...params } },
+		}));
+		if (ret === false) { return false; }
+		if (typeof ret === 'function') { return ret; }
+	}
+	return true;
 }
+
+/**
+ * 
+ * @param {Router | import('./main/types').Handler} route 
+ * @param {string[]} path 
+ * @param {import('./main/types').Context} ctx 
+ * @param {(v: any) => void} setParams 
+ * @param {object} params 
+ * @returns {Promise<import('./main/types').Handler | null>}
+ */
 async function find(route, path, ctx, setParams, params) {
-  if (!(route instanceof Router)) {
-    setParams(params);
-    return route;
-  }
-  if (route.disabled) {
-    return null;
-  }
-  const guardResult = await execGuard(route.guards, ctx, setParams, params);
-  if (!guardResult) {
-    return null;
-  }
-  if (typeof guardResult === 'function') {
-    return guardResult;
-  }
-  if (ctx.destroyed) {
-    return null;
-  }
-  for await (const [r, result, p] of route.find(ctx.method, path)) {
-    if (ctx.destroyed) {
-      return null;
-    }
-    const res = await find(r, p, ctx, setParams, {
-      ...params,
-      ...result
-    });
-    if (res) {
-      return res;
-    }
-  }
-  return null;
+	if (!(route instanceof Router)) {
+		setParams(params);
+		return route;
+	}
+	if (route.disabled) { return null; }
+	const guardResult = await execGuard(route.guards, ctx, setParams, params);
+	if (!guardResult) { return null; }
+	if (typeof guardResult === 'function') { return guardResult; }
+	if (ctx.destroyed) { return null; }
+	for await (const [r, result, p] of route.find(ctx.method, path)) {
+		if (ctx.destroyed) { return null; }
+		const res = await find(r, p, ctx, setParams, { ...params, ...result });
+		if (res) { return res; }
+	}
+	return null;
 }
+/**
+ * 
+ * @param {string} t 
+ * @returns 
+ */
 function uriDecode(t) {
-  try {
-    return decodeURIComponent(t);
-  } catch {
-    return t;
-  }
+	try {
+		return decodeURIComponent(t);
+	} catch {
+		return t;
+	}
 }
+/**
+ * @abstract
+ */
 class Router {
-  disabled = false;
-  static make(routers) {
-    return async (ctx, setParams) => {
-      const list = routers.flat();
-      const path = ctx.pathname.split('/').filter(Boolean).map(uriDecode);
-      for (const route of list) {
-        const res = await find(route, path, ctx, setParams, {});
-        if (res) {
-          return res;
-        }
-      }
-      return null;
-    };
-  }
-  static create(find) {
-    return Object.create(Router.prototype, {
-      'find': {
-        configurable: true,
-        value: find,
-        writable: true
-      }
-    });
-  }
-  guards = new Set();
+	disabled = false;
+	/**
+	 * @abstract
+	 * @param {import('./main/types').Method} method 
+	 * @param {string[]} path 
+	 * @returns {AsyncIterable<FindItem> | Iterable<FindItem>}
+	 */
+	find(method, path) { return [] }
+	/**
+	 * 
+	 * @param {Router[]} routers 
+	 * @returns {import('./main/types').FindHandler}
+	 */
+	static make(routers) {
+		return async (ctx, setParams) => {
+			const list = routers.flat();
+			const path = ctx.url.pathname.split('/').filter(Boolean).map(uriDecode);
+			for (const route of list) {
+				const res = await find(route, path, ctx, setParams, {});
+				if (res) { return res; }
+			}
+			return null;
+		};
+	}
+
+	/**
+	 * 
+	 * @param {Finder} find 
+	 * @returns {Router}
+	 */
+	static create(find) {
+		return Object.create(Router.prototype, {
+			'find': { configurable: true, value: find, writable: true },
+		});
+	}
+	/** @readonly @type {Set<Guard>} */
+	guards = new Set();
 }
 
-const regex$1 = /^:([a-zA-Z][a-zA-Z0-9]*)(?:\((.+)\))?([ius]+)?([?+*]?)$/;
+/**
+ * @typedef {object} Pattern
+ * @property {string} name
+ * @property {boolean} optional
+ * @property {boolean} many
+ * @property {RegExp} pattern
+ */
+
+const regex = /^:([a-zA-Z][a-zA-Z0-9]*)(?:\((.+)\))?([ius]+)?([?+*]?)$/;
+/**
+ * 
+ * @param {string} p 
+ * @returns {Pattern | string}
+ */
 function parse(p) {
-  const res = regex$1.exec(p);
-  if (!res) {
-    return p;
-  }
-  const [, name, expression = '.*', flags, modifier] = res;
-  if (!expression) {
-    return {
-      name,
-      pattern: new RegExp('^.*$', flags),
-      optional: modifier === '?' || modifier === '*',
-      many: modifier === '+' || modifier === '*'
-    };
-  }
-  let i = 0;
-  let count = 0;
-  const pattern = ['^(?:'];
-  while (i < expression.length) {
-    const c = expression[i++];
-    pattern.push(c);
-    if (c === '\\') {
-      pattern.push(expression[i++]);
-      continue;
-    }
-    if (c === ')') {
-      if (count === 0) {
-        return p;
-      }
-      count--;
-      continue;
-    }
-    if (c === '[') {
-      while (i < expression.length) {
-        const c = expression[i++];
-        pattern.push(c);
-        if (c === ']') {
-          break;
-        }
-        if (c !== '\\') {
-          continue;
-        }
-        pattern.push(expression[i++]);
-      }
-      continue;
-    }
-    if (c !== '(') {
-      continue;
-    }
-    count++;
-    if (expression[i] !== '?') {
-      continue;
-    }
-    i += 2;
-    if (expression[i - 1] === ':') {
-      continue;
-    }
-    return p;
-  }
-  if (count) {
-    return p;
-  }
-  pattern.push(')$');
-  return {
-    name,
-    pattern: new RegExp(pattern.join(''), flags),
-    optional: modifier === '?' || modifier === '*',
-    many: modifier === '+' || modifier === '*'
-  };
+	const res = regex.exec(p);
+	if (!res) { return p; }
+	const [, name, expression = '.*', flags, modifier] = res;
+	if (!expression) {
+		return {
+			name, pattern: new RegExp('^.*$', flags),
+			optional: modifier === '?' || modifier === '*',
+			many: modifier === '+' || modifier === '*',
+		};
+	}
+	let i = 0;
+	let count = 0;
+	/** @type {string[]} */
+	const pattern = ['^(?:'];
+	while (i < expression.length) {
+		const c = expression[i++];
+		pattern.push(c);
+		if (c === '\\') {
+			pattern.push(expression[i++]);
+			continue;
+		}
+		if (c === ')') {
+			if (count === 0) { return p; }
+			count--;
+			continue;
+		}
+		if (c === '[') {
+			while (i < expression.length) {
+				const c = expression[i++];
+				pattern.push(c);
+				if (c === ']') { break; }
+				if (c !== '\\') { continue; }
+				pattern.push(expression[i++]);
+			}
+			continue;
+		}
+		if (c !== '(') { continue; }
+		count++;
+		if (expression[i] !== '?') { continue; }
+		i += 2;
+		if (expression[i - 1] === ':') { continue; }
+		return p;
+	}
+	if (count) { return p; }
+	pattern.push(')$');
+	return {
+		name, pattern: new RegExp(pattern.join(''), flags),
+		optional: modifier === '?' || modifier === '*',
+		many: modifier === '+' || modifier === '*',
+	};
+
 }
+/**
+ * 
+ * @param {(Pattern | string)[]} match 
+ * @param {string[]} path 
+ * @param {boolean} end 
+ * @returns {[Record<string, string | string[]>, string[]] | undefined}
+ */
 function exec(match, path, end) {
-  const params = {};
-  for (let i = 0; i < match.length; i++) {
-    const m = match[i];
-    const p = path[i];
-    if (m === p) {
-      continue;
-    }
-    if (typeof m === 'string') {
-      return;
-    }
-    if (!p) {
-      return m.optional ? [params, []] : undefined;
-    }
-    if (!m.pattern.test(p)) {
-      return;
-    }
-    params[m.name] = p;
-  }
-  if (!end) {
-    return [params, path.slice(match.length)];
-  }
-  if (path.length <= match.length) {
-    return [params, []];
-  }
-  const last = match[match.length - 1];
-  if (typeof last === 'string') {
-    return;
-  }
-  if (!last.many && path.length > match.length) {
-    return;
-  }
-  for (let j = match.length; j < path.length; j++) {
-    if (!last.pattern.test(path[j])) {
-      return;
-    }
-  }
-  params[last.name] = path.slice(match.length - 1);
-  return [params, []];
+	/** @type {Record<string, string | string[]>} */
+	const params = {};
+	for (let i = 0; i < match.length; i++) {
+		const m = match[i];
+		const p = path[i];
+		if (m === p) { continue; }
+		if (typeof m === 'string') { return; }
+		if (!p) { return m.optional ? [params, []] : undefined; }
+		if (!m.pattern.test(p)) { return; }
+		params[m.name] = p;
+	}
+	if (!end) { return [params, path.slice(match.length)]; }
+	if (path.length <= match.length) { return [params, []]; }
+	const last = match[match.length - 1];
+	if (typeof last === 'string') { return; }
+	if (!last.many && path.length > match.length) { return; }
+	for (let j = match.length; j < path.length; j++) {
+		if (!last.pattern.test(path[j])) { return; }
+	}
+	params[last.name] = path.slice(match.length - 1);
+	return [params, []];
+
 }
+/**
+ * 
+ * @param {string} path 
+ * @param {boolean} end 
+ * @returns {import('./index.mjs').Match | undefined}
+ */
 function toMatch(path, end) {
-  const list = [];
-  for (const p of path.split('/')) {
-    if (!p || /^\.+$/.test(p)) {
-      continue;
-    }
-    list.push(parse(p));
-  }
-  if (!list.length) {
-    return;
-  }
-  return path => exec(list, path, end);
+	/** @type {(Pattern | string)[]} */
+	const list = [];
+	for (const p of path.split('/')) {
+		if (!p || /^\.+$/.test(p)) { continue; }
+		list.push(parse(p));
+	}
+	if (!list.length) { return; }
+	return path => exec(list, path, end);
 }
 
+/**
+ * 
+ * @param {(import('./index.mjs').Route | import('./index.mjs').RouterRoute)[]} routes 
+ * @param {import('../main/types').Method[]} methods 
+ * @param {string} path 
+ * @param {import('../main/types').Handler} handler 
+ * @returns {() => void}
+ */
 function bind(routes, methods, path, handler) {
-  const route = {
-    match: toMatch(path || '', true),
-    methods: new Set(methods),
-    handler
-  };
-  routes.push(route);
-  let removed = false;
-  return () => {
-    if (removed) {
-      return;
-    }
-    removed = true;
-    const index = routes.indexOf(route);
-    if (index < 0) {
-      return;
-    }
-    routes.splice(index, 1);
-  };
-}
+	/** @type {import('./index.mjs').Route} */
+	const route = {
+		match: toMatch(path || '', true),
+		methods: new Set(methods),
+		handler,
+	};
+	routes.push(route);
+	let removed = false;
+	return () => {
+		if (removed) { return; }
+		removed = true;
+		const index = routes.indexOf(route);
+		if (index < 0) { return; }
+		routes.splice(index, 1);
+	};
+}
+/** @type {(v: any) => v is import('../main/types').Handler} */
+const findHandler = v => typeof v === 'function';
+/**
+ * 
+ * @param {(import('./index.mjs').Route | import('./index.mjs').RouterRoute)[]} routes 
+ * @param {import('../main/types').Method[]} methods 
+ * @param {any[]} p 
+ * @returns {import('./index.mjs').Binder | (() => void)}
+ */
 function verb(routes, methods, p) {
-  if (!p.length) {
-    return handler => bind(routes, methods, '', handler);
-  }
-  const [a, b] = p;
-  if (a && typeof a === 'object') {
-    const path = String.raw(a, ...p.slice(1));
-    return handler => bind(routes, methods, path, handler);
-  }
-  const path = typeof a === 'string' ? a : '';
-  const handler = [a, b].find(v => typeof v === 'function');
-  if (!handler) {
-    return handler => bind(routes, methods, path, handler);
-  }
-  return bind(routes, methods, path, handler);
+	if (!p.length) {
+		return handler => bind(routes, methods, '', handler);
+	}
+	const [a, b] = p;
+	if (a && typeof a === 'object') {
+		const path = String.raw(a, ...p.slice(1));
+		return handler => bind(routes, methods, path, handler);
+	}
+	const path = typeof a === 'string' ? a : '';
+	const handler = [a, b].find(findHandler);
+	if (!handler) {
+		return handler => bind(routes, methods, path, handler);
+	}
+	return bind(routes, methods, path, handler);
 }
 
 const methods = new Set(['GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'OPTIONS']);
-function isMethod(v) {
-  return methods.has(v);
-}
+/**
+ * 
+ * @param {any} v 
+ * @returns {v is import('../main/types').Method}
+ */
+function isMethod(v) { return methods.has(v); }
+/**
+ * 
+ * @param {import('../main/types').Method | Iterable<import('../main/types').Method> | ArrayLike<import('../main/types').Method>} [methods] 
+ * @returns {import('../main/types').Method[]}
+ */
 function getMethods(methods) {
-  if (!methods) {
-    return ['GET', 'POST', 'PUT', 'DELETE'];
-  }
-  if (typeof methods === 'string') {
-    return [methods.toUpperCase()].filter(isMethod);
-  }
-  return Array.from(methods).map(v => typeof v === 'string' && v.toUpperCase()).filter(isMethod);
-}
-
-function bindRouter(routes, path, r) {
-  const router = r instanceof Router ? r : typeof r === 'function' ? Router.create(r) : new ApiRouter();
-  routes.push({
-    match: toMatch(path, false),
-    router
-  });
-  return router;
+	if (!methods) {
+		return ['GET', 'POST', 'PUT', 'DELETE'];
+	}
+	if (typeof methods === 'string') {
+		return [methods.toUpperCase()].filter(isMethod);
+	}
+	return Array.from(methods)
+		.map(v => typeof v === 'string' && v.toUpperCase())
+		.filter(isMethod);
 }
-class ApiRouter extends Router {
-  /** 路由列表 */
-  #routes = [];
-  /**
-   * 添加子路由
-   * @param router 要注册的子路由
-   */
-
-  /**
-   * 添加子路由
-   * @param path   要注册的路径
-   * @param router 要注册的子路由
-   */
-
-  /**
-   * 添加子路由
-   * @param path   要注册的路径
-   */
-
-  /**
-   * 添加子路由
-   * @param find 要注册的子路由的 Finder
-   */
-
-  /**
-   * 添加子路由
-   * @param path 要注册的路径
-   * @param find 要注册的子路由的 Finder
-   */
-
-  route(...p) {
-    const [a] = p;
-    if (a && typeof a === 'object' && !(a instanceof Router)) {
-      const path = String.raw(a, ...p.slice(1));
-      return r => bindRouter(this.#routes, path, r);
-    }
-    const path = typeof a === 'string' ? a : '';
-    const r = typeof a === 'string' ? p[1] : a;
-    return bindRouter(this.#routes, path, r);
-  }
-  *find(method, path) {
-    for (const route of Array.from(this.#routes)) {
-      if (!route.router && !route.methods.has(method)) {
-        continue;
-      }
-      const {
-        match
-      } = route;
-      if (!match) {
-        if (route.router || !path.length) {
-          yield [route.router || route.handler, {}, path];
-        }
-        continue;
-      }
-      if (!path.length) {
-        continue;
-      }
-      const result = match(path);
-      if (!result) {
-        continue;
-      }
-      yield [route.router || route.handler, ...result];
-    }
-  }
-  /**
-   * 注册处理函数
-   * @param method  要注册的方法
-   * @param handler 要注册的处理函数
-   */
 
-  /**
-   * 注册处理函数
-   * @param method  要注册的方法
-   * @param path    要注册的路径
-   * @param handler 要注册的处理函数
-   */
-
-  /**
-   * 注册处理函数
-   * @param method 要注册的方法
-   * @param path   要注册的路径
-   */
-
-  verb(methods, path, handler) {
-    const allMethods = getMethods(methods);
-    if (!allMethods.length) {
-      return () => {};
-    }
-    return verb(this.#routes, allMethods, [path, handler]);
-  }
-  /**
-   * 注册 HTTP GET/POST/PUT/DELETE 处理函数
-   * @param handler 要注册的处理函数
-   */
-
-  /**
-   * 注册处理函数
-   * @param path    要注册的路径
-   * @param handler 要注册的处理函数
-   */
-
-  /**
-   * 注册 HTTP GET/POST/PUT/DELETE 处理函数
-   * @param path 要注册的路径
-   */
-
-  /**
-   * 注册 HTTP GET/POST/PUT/DELETE 处理函数
-   * @param path 要注册的路径
-   */
-
-  match(...p) {
-    return verb(this.#routes, ['GET', 'POST', 'PUT', 'DELETE'], p);
-  }
-  /**
-   * 注册 HTTP GET 处理函数
-   * @param handler 要注册的处理函数
-   */
-
-  /**
-   * 注册 HTTP GET 处理函数
-   * @param path    要注册的路径
-   * @param handler 要注册的处理函数
-   */
-
-  /**
-   * 注册 HTTP GET 处理函数
-   * @param path 要注册的路径
-   */
-
-  /**
-   * 注册 HTTP GET 处理函数
-   * @param path 要注册的路径
-   */
-
-  get(...p) {
-    return verb(this.#routes, ['GET'], p);
-  }
-  /**
-   * 注册 HTTP POST 处理函数
-   * @param handler 要注册的处理函数
-   */
-
-  /**
-   * 注册 HTTP POST 处理函数
-   * @param path    要注册的路径
-   * @param handler 要注册的处理函数
-   */
-
-  /**
-   * 注册 HTTP POST 处理函数
-   * @param path 要注册的路径
-   */
-
-  /**
-   * 注册 HTTP POST 处理函数
-   * @param path 要注册的路径
-   */
-
-  post(...p) {
-    return verb(this.#routes, ['POST'], p);
-  }
-  /**
-   * 注册 HTTP PUT 处理函数
-   * @param handler 要注册的处理函数
-   */
-
-  /**
-   * 注册 HTTP PUT 处理函数
-   * @param path    要注册的路径
-   * @param handler 要注册的处理函数
-   */
-
-  /**
-   * 注册 HTTP PUT 处理函数
-   * @param path 要注册的路径
-   */
-
-  /**
-   * 注册 HTTP PUT 处理函数
-   * @param path 要注册的路径
-   */
-
-  put(...p) {
-    return verb(this.#routes, ['PUT'], p);
-  }
-  /**
-   * 注册 HTTP DELETE 处理函数
-   * @param handler 要注册的处理函数
-   */
-
-  /**
-   * 注册 HTTP DELETE 处理函数
-   * @param path    要注册的路径
-   * @param handler 要注册的处理函数
-   */
-
-  /**
-   * 注册 HTTP DELETE 处理函数
-   * @param path 要注册的路径
-   */
-
-  /**
-   * 注册 HTTP DELETE 处理函数
-   * @param path 要注册的路径
-   */
-
-  delete(...p) {
-    return verb(this.#routes, ['DELETE'], p);
-  }
-  /**
-   * 注册 HTTP HEAD 处理函数
-   * @param handler 要注册的处理函数
-   */
-
-  /**
-   * 注册 HTTP HEAD 处理函数
-   * @param path    要注册的路径
-   * @param handler 要注册的处理函数
-   */
-
-  /**
-   * 注册 HTTP HEAD 处理函数
-   * @param path 要注册的路径
-   */
-
-  /**
-   * 注册 HTTP HEAD 处理函数
-   * @param path 要注册的路径
-   */
+/**
+ * @callback Match
+ * @param {string[]} paths
+ * @returns {[Record<string, string | string[]>, string[]] | undefined}
+ */
 
-  head(...p) {
-    return verb(this.#routes, ['HEAD'], p);
-  }
-  /**
-   * 注册 HTTP OPTIONS 处理函数
-   * @param handler 要注册的处理函数
-   */
+/**
+ * @callback Binder
+ * @param {import('../main/types').Handler} handler
+ * @returns {() => void}
+ */
 
-  /**
-   * 注册 HTTP OPTIONS 处理函数
-   * @param path    要注册的路径
-   * @param handler 要注册的处理函数
-   */
+/**
+ * @typedef {object} Route
+ * @property {Match} [match] 路径匹配
+ * @property {null} [router]
+ * @property {string} [plugin] 所属插件
+ * @property {import('../main/types').Handler} handler 处理函数
+ * @property {Set<import('../main/types').Method>} methods 方法列表
+ */
 
-  /**
-   * 注册 HTTP OPTIONS 处理函数
-   * @param path 要注册的路径
-   */
+/**
+ * @typedef {object} RouterRoute
+ * @property {Match} [match] 路径匹配
+ * @property {Router} router
+ */
 
-  /**
-   * 注册 HTTP OPTIONS 处理函数
-   * @param path 要注册的路径
-   */
 
-  options(...p) {
-    return verb(this.#routes, ['OPTIONS'], p);
-  }
+/**
+ * @template {Router | import('../Router.mjs').Finder} [T=ApiRouter]
+ * @callback RouteBinder
+ * @param {T} [router] 要注册的子路由或子路由的 Finder
+ * @returns {T extends import('../Router.mjs').Finder ? Router : T}
+ */
+/**
+ * 
+ * @param {(Route | RouterRoute)[]} routes 
+ * @param {string} path 
+ * @param {Router | import('../Router.mjs').Finder} [r] 
+ * @returns {Router}
+ */
+function bindRouter(routes, path, r) {
+	const router = r instanceof Router ? r
+		: typeof r === 'function' ? Router.create(r)
+			: new ApiRouter();
+	routes.push({ match: toMatch(path, false), router });
+	return router;
+}
+class ApiRouter extends Router {
+	/** @readonly @type {(Route | RouterRoute)[]} 路由列表 */
+	#routes = [];
+	/**
+	 * 添加子路由
+	 * @template {Router | import('../Router.mjs').Finder} [T=ApiRouter]
+	 * @overload
+	 * @param {T} [router] 要注册的子路由或子路由的 Finder
+	 * @returns {T extends import('../Router.mjs').Finder ? Router : T}
+	 */
+	/**
+	 * 添加子路由
+	 * @template {Router | import('../Router.mjs').Finder} [T=ApiRouter]
+	 * @overload
+	 * @param {string} path   要注册的路径
+	 * @param {T} [router] 要注册的子路由或子路由的 Finder
+	 * @returns {T extends import('../Router.mjs').Finder ? Router : T}
+	 */
+	/**
+	 * 添加子路由
+	 * @overload
+	 * @param {...Parameters<typeof String.raw>} path 要注册的路径
+	 * @returns {RouteBinder}
+	 */
+	/**
+	 * 添加子路由
+	 * @param {...any} p 要注册的路径
+	 * @returns {Router | RouteBinder}
+	 */
+	route(...p) {
+		const [a] = p;
+		if (a && typeof a === 'object' && !(a instanceof Router)) {
+			const path = String.raw(a, ...p.slice(1));
+			/**
+			 * @param { import('../Router.mjs').Finder | Router} [r];
+			 * @returns {any}
+			 */
+			return r => bindRouter(this.#routes, path, r);
+		}
+		const path = typeof a === 'string' ? a : '';
+		const r = typeof a === 'string' ? p[1] : a;
+		return bindRouter(this.#routes, path, r);
+	}
+	/**
+	 * 
+	 * @param {import('../main/types').Method} method 
+	 * @param {string[]} path 
+	 * @returns {Iterable<import('../Router.mjs').FindItem>}
+	 */
+	*find(method, path) {
+		for (const route of Array.from(this.#routes)) {
+			if (!route.router && !route.methods.has(method)) { continue; }
+			const {match} = route;
+			if (!match) {
+				if (route.router || !path.length) {
+					yield [route.router || route.handler, {}, path];
+				}
+				continue;
+			}
+			if (!path.length) { continue; }
+			const result = match(path);
+			if (!result) { continue; }
+			yield [route.router || route.handler, ...result];
+		}
+	}
+	/**
+	 * 注册处理函数
+	 * @overload
+	 * @param {import('../main/types').Method | Iterable<import('../main/types').Method> | ArrayLike<import('../main/types').Method>} method  要注册的方法
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册处理函数
+	 * @overload
+	 * @param {import('../main/types').Method | Iterable<import('../main/types').Method> | ArrayLike<import('../main/types').Method>} method  要注册的方法
+	 * @param {string} path 要注册的路径
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册处理函数
+	 * @overload
+	 * @param {import('../main/types').Method | Iterable<import('../main/types').Method> | ArrayLike<import('../main/types').Method>} method  要注册的方法
+	 * @param {string} path   要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * @param {import('../main/types').Method | Iterable<import('../main/types').Method> | ArrayLike<import('../main/types').Method>} methods 
+	 * @param {string| import('../main/types').Handler} [path]
+	 * @param {import('../main/types').Handler} [handler]
+	 * @returns {Binder | (() => void)}
+	 */
+	verb(methods, path, handler) {
+		const allMethods = getMethods(methods);
+		if (!allMethods.length) { return () => {}; }
+		return verb(this.#routes, allMethods, [path, handler]);
+	}
+	/**
+	 * 注册 HTTP GET/POST/PUT/DELETE 处理函数
+	 * @overload
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册处理函数
+	 * @overload
+	 * @param {string} path 要注册的路径
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册 HTTP GET/POST/PUT/DELETE 处理函数
+	 * @overload
+	 * @param {string} path 要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * 注册 HTTP GET/POST/PUT/DELETE 处理函数
+	 * @overload
+	 * @param {...Parameters<typeof String.raw>} path 要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * @param {...any} p 要注册的路径
+	 * @returns {Binder | (() => void)}
+	 */
+	match(...p) {
+		return verb(this.#routes, ['GET', 'POST', 'PUT', 'DELETE'], p);
+	}
+	/**
+	 * 注册 HTTP GET 处理函数
+	 * @overload
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册 HTTP GET 处理函数
+	 * @overload
+	 * @param {string} path 要注册的路径
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册 HTTP GET 处理函数
+	 * @overload
+	 * @param {string} path 要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * 注册 HTTP GET 处理函数
+	 * @overload
+	 * @param {...Parameters<typeof String.raw>} path 要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * @param {...any} p 要注册的路径
+	 * @returns {Binder | (() => void)}
+	 */
+	get(...p) { return verb(this.#routes, ['GET'], p); }
+	/**
+	 * 注册 HTTP POST 处理函数
+	 * @overload
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册 HTTP POST 处理函数
+	 * @overload
+	 * @param {string} path 要注册的路径
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册 HTTP POST 处理函数
+	 * @overload
+	 * @param {string} path 要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * 注册 HTTP POST 处理函数
+	 * @overload
+	 * @param {...Parameters<typeof String.raw>} path 要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * @param {...any} p 要注册的路径
+	 * @returns {Binder | (() => void)}
+	 */
+	post(...p) { return verb(this.#routes, ['POST'], p); }
+	/**
+	 * 注册 HTTP PUT 处理函数
+	 * @overload
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册 HTTP PUT 处理函数
+	 * @overload
+	 * @param {string} path 要注册的路径
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册 HTTP PUT 处理函数
+	 * @overload
+	 * @param {string} path 要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * 注册 HTTP PUT 处理函数
+	 * @overload
+	 * @param {...Parameters<typeof String.raw>} path 要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * @param {...any} p 要注册的路径
+	 * @returns {Binder | (() => void)}
+	 */
+	put(...p) { return verb(this.#routes, ['PUT'], p); }
+	/**
+	 * 注册 HTTP DELETE 处理函数
+	 * @overload
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册 HTTP DELETE 处理函数
+	 * @overload
+	 * @param {string} path 要注册的路径
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册 HTTP DELETE 处理函数
+	 * @overload
+	 * @param {string} path 要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * 注册 HTTP DELETE 处理函数
+	 * @overload
+	 * @param {...Parameters<typeof String.raw>} path 要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * @param {...any} p 要注册的路径
+	 * @returns {Binder | (() => void)}
+	 */
+	delete(...p) { return verb(this.#routes, ['DELETE'], p); }
+	/**
+	 * 注册 HTTP HEAD 处理函数
+	 * @overload
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册 HTTP HEAD 处理函数
+	 * @overload
+	 * @param {string} path 要注册的路径
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册 HTTP HEAD 处理函数
+	 * @overload
+	 * @param {string} path 要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * 注册 HTTP HEAD 处理函数
+	 * @overload
+	 * @param {...Parameters<typeof String.raw>} path 要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * @param {...any} p 要注册的路径
+	 * @returns {Binder | (() => void)}
+	 */
+	head(...p) { return verb(this.#routes, ['HEAD'], p); }
+	/**
+	 * 注册 HTTP OPTIONS 处理函数
+	 * @overload
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册 HTTP OPTIONS 处理函数
+	 * @overload
+	 * @param {string} path 要注册的路径
+	 * @param {import('../main/types').Handler} handler 要注册的处理函数
+	 * @returns {() => void}
+	 */
+	/**
+	 * 注册 HTTP OPTIONS 处理函数
+	 * @overload
+	 * @param {string} path 要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * 注册 HTTP OPTIONS 处理函数
+	 * @overload
+	 * @param {...Parameters<typeof String.raw>} path 要注册的路径
+	 * @returns {Binder}
+	 */
+	/**
+	 * @param {...any} p 要注册的路径
+	 * @returns {Binder | (() => void)}
+	 */
+	options(...p) { return verb(this.#routes, ['OPTIONS'], p); }
 }
 
-const idRegexText = '[a-zA-Z][a-zA-Z0-9_-]*';
-const kRegexText = `${idRegexText}(?:.${idRegexText})*`;
-const regexText = `^/(${idRegexText})/((?:@${kRegexText}/)?${kRegexText})/(.+)$`;
-const regex = new RegExp(regexText);
-class Plugin {
-  static make(plugins, {
-    router,
-    setting,
-    asset,
-    log,
-    runner
-  } = {}) {
-    const routers = [];
-    for (const plugin of Object.values(plugins)) {
-      routers.push(plugin.router);
-    }
-    if (router instanceof Router) {
-      routers.push(router);
-    }
-    return make(Router.make(routers), {
-      setting,
-      asset: Plugin.bindAsset(asset, plugins),
-      log,
-      runner
-    });
-  }
-  static bindAsset(api, plugins, pluginPath = 'plugins') {
-    if (!plugins) {
-      return api;
-    }
-    const read = api?.read;
-    if (typeof read !== 'function') {
-      return api;
-    }
-    return {
-      ...api,
-      read: async path => {
-        const ret = await read(path);
-        if (ret !== null) {
-          return ret;
-        }
-        if (!plugins) {
-          return null;
-        }
-        const r = regex.exec(path);
-        if (!r) {
-          return null;
-        }
-        const [, base, name, subpath] = r;
-        if (base !== pluginPath) {
-          return null;
-        }
-        if (!(name in plugins)) {
-          return null;
-        }
-        const plugin = plugins[name];
-        if (!plugin) {
-          return null;
-        }
-        return plugin.readAsset(subpath);
-      }
-    };
-  }
-
-  /** 包名 */
-
-  /** 版本 */
-
-  /** 作者 */
-
-  /** 开源协议 */
-
-  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() {
-    const {
-      router
-    } = this;
-    if (this.__initRouterPromise) {
-      return this.__initRouterPromise;
-    }
-    return this.__initRouterPromise = Promise.resolve(this._initRouter(router)).then(() => router);
-  }
-  get router() {
-    const router = this._createRouter();
-    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;
-  }
+/**
+ * 
+ * @param {(request: Request) => Promise<Response | null>} run 
+ * @param {((request: Request) => Response | Promise<Response>)?} [notFound] 
+ * @returns {(input: RequestInfo, init?: RequestInit) => Promise<Response>}
+ */
+function createFetch(run, notFound) {
+	/**
+	 * @param {RequestInfo} input
+	 * @param {RequestInit} [init]
+	 * @returns {Promise<Response>}
+	 */
+	return async function fetch(input, init) {
+		const request = new Request(input, init);
+		const {signal} = request;
+		signal.throwIfAborted();
+		const r = await run(request);
+		if (r) { return r; }
+		if (typeof notFound === 'function') { return notFound(request); }
+		return new Response(null, { status: 404 });
+	};
 }
 
 exports.ApiRouter = ApiRouter;
-exports.Plugin = Plugin;
 exports.Router = Router;
-exports.createEnvironment = createEnvironment;
+exports.createFetch = createFetch;
 exports.main = main;
 exports.make = make;
 exports.merge = merge;
-exports.run = run;
 exports.service = service;
 exports.stateService = stateService;
 exports.storeService = storeService;