@radatek/microserver 2.3.10 → 3.0.1

package/microserver.js

@@ -1,6 +1,6 @@
 /**
  * MicroServer
- * @version 2.3.10
+ * @version 3.0.0
  * @package @radatek/microserver
  * @copyright Darius Kisonas 2022
  * @license MIT
@@ -16,10 +16,12 @@ import path, { basename, extname } from 'path';
 import crypto from 'crypto';
 import zlib from 'zlib';
 import { EventEmitter } from 'events';
+import { nextTick } from 'process';
 const defaultToken = 'wx)>:ZUqVc+E,u0EmkPz%ZW@TFDY^3vm';
 const defaultExpire = 24 * 60 * 60;
 const defaultMaxBodySize = 5 * 1024 * 1024;
 const defaultMethods = 'HEAD,GET,POST,PUT,PATCH,DELETE';
+const defaultMaxFileSize = 20 * 1024 * 1024;
 function NOOP(...args) { }
 function isFunction(fn) {
     if (typeof fn !== 'function')
@@ -32,11 +34,12 @@ export class Warning extends Error {
         super(text);
     }
 }
-const commonCodes = { 404: 'Not found', 403: 'Access denied', 422: 'Invalid data' };
-const commonTexts = { 'Not found': 404, 'Access denied': 403, 'Permission denied': 422, 'Invalid data': 422, InvalidData: 422, AccessDenied: 403, NotFound: 404, Failed: 422, OK: 200 };
+const commonCodes = { 404: 'Not found', 403: 'Access denied', 405: 'Not allowed', 422: 'Invalid data' };
+const commonTexts = { 'Not found': 404, 'Access denied': 403, 'Not allowed': 405, 'Permission denied': 422, 'Invalid data': 422, InvalidData: 422, AccessDenied: 403, NotFound: 404, NotAllowed: 405, Failed: 422, OK: 200 };
 export class ResponseError extends Error {
     static getStatusCode(text) { return typeof text === 'number' ? text : text && commonTexts[text] || 500; }
     static getStatusText(text) { return typeof text === 'number' ? commonCodes[text] : text?.toString() || 'Error'; }
+    statusCode;
     constructor(text, statusCode) {
         super(ResponseError.getStatusText(text || statusCode || 500));
         this.statusCode = ResponseError.getStatusCode(statusCode || text) || 500;
@@ -54,31 +57,84 @@ export class NotFound extends ResponseError {
     constructor(text) { super(text, 404); }
 }
 export class WebSocketError extends Error {
+    statusCode;
     constructor(text, code) {
         super(text);
         this.statusCode = code || 1002;
     }
 }
+function deferPromise(cb) {
+    let _resolve;
+    const p = new Promise((resolve, reject) => {
+        _resolve = (res) => {
+            cb?.(res);
+            if (res instanceof Error)
+                reject(res);
+            else
+                resolve(res);
+        };
+    });
+    p.resolve = _resolve;
+    return p;
+}
 export class Plugin {
-    constructor(router, ...args) { }
+    name;
+    priority;
+    constructor() { }
 }
+// #region ServerRequest/ServerResponse
 /** Extended http.IncomingMessage */
 export class ServerRequest extends http.IncomingMessage {
-    constructor(router) {
+    /** Request client IP */
+    ip;
+    /** Request from local network */
+    localip;
+    /** Request is secure (https) */
+    secure;
+    /** Request whole path */
+    path = '/';
+    /** Request pathname */
+    pathname = '/';
+    /** Base url */
+    baseUrl = '/';
+    /** Original url */
+    originalUrl;
+    /** Query parameters */
+    query;
+    /** Router named parameters */
+    params;
+    /** Router named parameters list */
+    paramsList;
+    /** Router */
+    server;
+    /** Authentication object */
+    auth;
+    /** Authenticated user info */
+    user;
+    /** Model used for request */
+    model;
+    /** Authentication token id */
+    tokenId;
+    /** Request raw body */
+    rawBody;
+    /** Request raw body size */
+    rawBodySize;
+    _body;
+    _isReady;
+    constructor(server) {
         super(new net.Socket());
-        /** Request whole path */
-        this.path = '/';
-        /** Request pathname */
-        this.pathname = '/';
-        /** Base url */
-        this.baseUrl = '/';
-        this._init(router);
-    }
-    _init(router) {
-        Object.assign(this, {
-            router,
-            auth: router.auth,
-            protocol: 'encrypted' in this.socket && this.socket.encrypted ? 'https' : 'http',
+        ServerRequest.extend(this, server);
+    }
+    static extend(req, server) {
+        const reqNew = Object.setPrototypeOf(req, ServerRequest.prototype);
+        let ip = req.socket.remoteAddress || '::1';
+        if (ip.startsWith('::ffff:'))
+            ip = ip.slice(7);
+        Object.assign(reqNew, {
+            server,
+            ip,
+            auth: server.auth,
+            protocol: 'encrypted' in req.socket && req.socket.encrypted ? 'https' : 'http',
             query: {},
             params: {},
             paramsList: [],
@@ -88,7 +144,16 @@ export class ServerRequest extends http.IncomingMessage {
             rawBody: [],
             rawBodySize: 0
         });
-        this.updateUrl(this.url || '/');
+        reqNew.updateUrl(req.url || '/');
+        return reqNew;
+    }
+    get isReady() {
+        return this._isReady === undefined;
+    }
+    async waitReady() {
+        if (this._isReady === undefined)
+            return;
+        await this._isReady;
     }
     /** Update request url */
     updateUrl(url) {
@@ -101,6 +166,7 @@ export class ServerRequest extends http.IncomingMessage {
         this.baseUrl = pathname.slice(0, pathname.length - this.path.length);
         this.query = {};
         parsedUrl.searchParams.forEach((v, k) => this.query[k] = v);
+        return this;
     }
     /** Rewrite request url */
     rewrite(url) {
@@ -108,26 +174,6 @@ export class ServerRequest extends http.IncomingMessage {
     }
     /** Request body: JSON or POST parameters */
     get body() {
-        if (!this._body) {
-            if (this.method === 'GET')
-                this._body = {};
-            else {
-                const contentType = this.headers['content-type'] || '', charset = contentType.match(/charset=(\S+)/);
-                let bodyString = Buffer.concat(this.rawBody).toString((charset ? charset[1] : 'utf8'));
-                this._body = {};
-                if (bodyString.startsWith('{') || bodyString.startsWith('[')) {
-                    try {
-                        this._body = JSON.parse(bodyString);
-                    }
-                    catch {
-                        throw new Error('Invalid request format');
-                    }
-                }
-                else if (contentType.startsWith('application/x-www-form-urlencoded')) {
-                    this._body = querystring.parse(bodyString);
-                }
-            }
-        }
         return this._body;
     }
     /** Alias to body */
@@ -136,188 +182,28 @@ export class ServerRequest extends http.IncomingMessage {
     }
     /** Get websocket */
     get websocket() {
-        if (!this._websocket) {
-            if (!this.headers.upgrade)
-                throw new Error('Invalid WebSocket request');
-            this._websocket = new WebSocket(this, {
-                permessageDeflate: this.router.server.config.websocketCompress,
-                maxPayload: this.router.server.config.websocketMaxPayload || 1024 * 1024,
-                maxWindowBits: this.router.server.config.websocketMaxWindowBits || 10
-            });
-        }
-        if (!this._websocket.ready)
-            throw new Error('Invalid WebSocket request');
-        return this._websocket;
+        throw new Error('WebSocket not initialized');
     }
     /** get files list in request */
     async files() {
-        this.resume();
-        delete this.headers.connection;
-        const files = this._files;
-        if (files) {
-            if (files.resolve !== NOOP)
-                throw new Error('Invalid request files usage');
-            return new Promise((resolve, reject) => {
-                files.resolve = err => {
-                    files.done = true;
-                    files.resolve = NOOP;
-                    if (err)
-                        reject(err);
-                    else
-                        resolve(files.list);
-                };
-                if (files.done)
-                    files.resolve();
-            });
-        }
-    }
-    /** Decode request body */
-    bodyDecode(res, options, next) {
-        const contentType = (this.headers['content-type'] || '').split(';');
-        const maxSize = options.maxBodySize || defaultMaxBodySize;
-        if (contentType.includes('multipart/form-data')) {
-            const chunkParse = (chunk) => {
-                const files = this._files;
-                if (!files || files.done)
-                    return;
-                chunk = files.chunk = files.chunk ? Buffer.concat([files.chunk, chunk]) : chunk;
-                const p = chunk.indexOf(files.boundary) || -1;
-                if (p >= 0 && chunk.length - p >= 2) {
-                    if (files.last) {
-                        if (p > 0)
-                            files.last.write(chunk.subarray(0, p));
-                        files.last.srtream.close();
-                        delete files.last.srtream;
-                        files.last = undefined;
-                    }
-                    let pe = p + files.boundary.length;
-                    if (chunk[pe] === 13 && chunk[pe + 1] === 10) {
-                        chunk = files.chunk = chunk.subarray(p);
-                        // next header
-                        pe = chunk.indexOf('\r\n\r\n');
-                        if (pe > 0) { // whole header
-                            const header = chunk.toString('utf8', files.boundary.length + 2, pe);
-                            chunk = chunk.subarray(pe + 4);
-                            const fileInfo = header.match(/content-disposition: ([^\r\n]+)/i);
-                            const contentType = header.match(/content-type: ([^\r\n;]+)/i);
-                            let fieldName = '', fileName = '';
-                            if (fileInfo)
-                                fileInfo[1].replace(/(\w+)="?([^";]+)"?/, (_, n, v) => {
-                                    if (n === 'name')
-                                        fieldName = v;
-                                    if (n === 'filename')
-                                        fileName = v;
-                                    return _;
-                                });
-                            if (fileName) {
-                                let file;
-                                do {
-                                    file = path.resolve(path.join(files.uploadDir, crypto.randomBytes(16).toString('hex') + '.tmp'));
-                                } while (fs.existsSync(file));
-                                files.last = {
-                                    name: fieldName,
-                                    fileName: fileName,
-                                    contentType: contentType && contentType[1],
-                                    file: file,
-                                    stream: fs.createWriteStream(file)
-                                };
-                                files.list.push(files.last);
-                            }
-                            else if (fieldName) {
-                                files.last = {
-                                    name: fieldName,
-                                    stream: {
-                                        write: (chunk) => {
-                                            if (!this._body)
-                                                this._body = {};
-                                            this._body[fieldName] = (this._body[fieldName] || '') + chunk.toString();
-                                        },
-                                        close() { }
-                                    }
-                                };
-                            }
-                        }
-                    }
-                    else {
-                        files.chunk = undefined;
-                        files.done = true;
-                    }
-                }
-                else {
-                    if (chunk.length > 8096) {
-                        if (files.last)
-                            files.last.stream.write(chunk.subarray(0, files.boundary.length - 1));
-                        chunk = files.chunk = chunk.subarray(files.boundary.length - 1);
-                    }
-                }
-            };
-            this.pause();
-            //res.setHeader('Connection', 'close') // TODO: check if this is needed
-            this._body = {};
-            const files = this._files = {
-                list: [],
-                uploadDir: path.resolve(options.uploadDir || 'upload'),
-                resolve: NOOP,
-                boundary: ''
-            };
-            if (!contentType.find(l => {
-                const p = l.indexOf('boundary=');
-                if (p >= 0) {
-                    files.boundary = '\r\n--' + l.slice(p + 9).trim();
-                    return true;
-                }
-            }))
-                return res.error(400);
-            next();
-            this.once('error', () => files.resolve(new ResponseError('Request error')))
-                .on('data', chunk => chunkParse(chunk))
-                .once('end', () => files.resolve(new Error('Request error')));
-            res.on('finish', () => this._removeTempFiles());
-            res.on('error', () => this._removeTempFiles());
-            res.on('close', () => this._removeTempFiles());
-        }
-        else {
-            this.once('error', err => console.error(err))
-                .on('data', chunk => {
-                this.rawBodySize += chunk.length;
-                if (this.rawBodySize >= maxSize) {
-                    this.pause();
-                    res.setHeader('Connection', 'close');
-                    res.error(413);
-                }
-                else
-                    this.rawBody.push(chunk);
-            })
-                .once('end', next);
-        }
-    }
-    _removeTempFiles() {
-        if (this._files) {
-            if (!this._files.done) {
-                this.pause();
-                this._files.resolve(new Error('Invalid request files usage'));
-            }
-            this._files.list.forEach(f => {
-                if (f.stream)
-                    f.stream.close();
-                if (f.file)
-                    fs.unlink(f.file, NOOP);
-            });
-            this._files = undefined;
-        }
+        throw new Error('Upload not initialized');
     }
 }
 /** Extends http.ServerResponse */
 export class ServerResponse extends http.ServerResponse {
-    constructor(router) {
-        super(new http.IncomingMessage(new net.Socket()));
-        this._init(router);
+    isJson;
+    headersOnly;
+    constructor(server) {
+        super(ServerRequest.extend(new http.IncomingMessage(new net.Socket()), server));
+        ServerResponse.extend(this);
     }
-    _init(router) {
-        this.router = router;
-        this.isJson = false;
-        this.headersOnly = false;
-        this.statusCode = 200;
+    static extend(res) {
+        Object.setPrototypeOf(res, ServerResponse.prototype);
+        Object.assign(res, {
+            statusCode: 200,
+            isJson: false,
+            headersOnly: false
+        });
     }
     /** Send error reponse */
     error(error) {
@@ -366,13 +252,18 @@ export class ServerResponse extends http.ServerResponse {
                 this.send(text != null ? text : (this.statusCode + ' ' + (commonCodes[this.statusCode] || http.STATUS_CODES[this.statusCode])));
         }
         catch (e) {
-            this.statusCode = 500;
-            this.send('Internal error');
-            console.error(e);
+            this.status(500).send('Internal error');
+            this.req.server.emit('error', e);
         }
     }
     /** Sets Content-Type acording to data and sends response */
     send(data = '') {
+        if (this.headersSent)
+            return;
+        if (!this.req.complete) {
+            this.req.pause();
+            this.setHeader('Connection', 'close');
+        }
         if (data instanceof Readable)
             return (data.pipe(this, { end: true }), void 0);
         if (!this.getHeader('Content-Type') && !(data instanceof Buffer)) {
@@ -412,14 +303,14 @@ export class ServerResponse extends http.ServerResponse {
         if (typeof error === 'number')
             error = http.STATUS_CODES[error] || 'Error';
         if (error instanceof Error)
-            return this.json(error);
+            return this.error(error);
         this.json(typeof error === 'string' ? { success: false, error } : { success: false, ...error });
     }
     /** Send json response in form { success: true, ... } */
     jsonSuccess(data) {
         this.isJson = true;
         if (data instanceof Error)
-            return this.json(data);
+            return this.error(data);
         this.json(typeof data === 'string' ? { success: true, message: data } : { success: true, ...data });
     }
     /** Send redirect response to specified URL with optional status code (default: 302) */
@@ -433,1174 +324,1196 @@ export class ServerResponse extends http.ServerResponse {
         this.statusCode = code || 302;
         this.end();
     }
+    /** Rewrite URL */
+    rewrite(url) {
+        return this.req.rewrite(url);
+    }
     /** Set status code */
     status(code) {
         this.statusCode = code;
         return this;
     }
-    file(path, filename) {
-        StaticPlugin.serveFile(this.req, this, {
-            path: path,
-            filename: filename || basename(path),
-            mimeType: StaticPlugin.mimeTypes[extname(path)] || 'application/octet-stream'
-        });
+    /** Send file */
+    file(path) {
+        throw new Error('Not implemented');
     }
 }
-const EMPTY_BUFFER = Buffer.alloc(0);
-const DEFLATE_TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
-/** WebSocket class */
-export class WebSocket extends EventEmitter {
-    constructor(req, options) {
+/** Lighweight HTTP server */
+export class MicroServer extends EventEmitter {
+    config;
+    auth;
+    _stack = [];
+    _router = new RouterPlugin();
+    _worker = new Worker();
+    /** all sockets */
+    sockets;
+    /** server instances */
+    servers;
+    /** @param {MicroServerConfig} [config] MicroServer configuration  */
+    constructor(config) {
         super();
-        this._buffers = [EMPTY_BUFFER];
-        this._buffersLength = 0;
-        this.ready = false;
-        this._socket = req.socket;
-        this._options = {
-            maxPayload: 1024 * 1024,
-            permessageDeflate: false,
-            maxWindowBits: 15,
-            timeout: 120000,
-            ...options
-        };
-        this._socket.setTimeout(this._options.timeout || 120000);
-        const key = req.headers['sec-websocket-key'];
-        const upgrade = req.headers.upgrade;
-        const version = +(req.headers['sec-websocket-version'] || 0);
-        const extensions = req.headers['sec-websocket-extensions'];
-        const headers = [];
-        if (!key || !upgrade || upgrade.toLocaleLowerCase() !== 'websocket' || version !== 13 || req.method !== 'GET') {
-            this._abort('Invalid WebSocket request', 400);
-            return;
-        }
-        if (this._options.permessageDeflate && extensions?.includes('permessage-deflate')) {
-            let header = 'Sec-WebSocket-Extensions: permessage-deflate';
-            if ((this._options.maxWindowBits || 15) < 15 && extensions.includes('client_max_window_bits'))
-                header += `; client_max_window_bits=${this._options.maxWindowBits}`;
-            headers.push(header);
-            this._options.deflate = true;
+        this.config = config || {};
+        this.use(this._router);
+        if (config) {
+            if (this.config.routes)
+                this.use(this.config.routes);
+            if (this.config.listen) {
+                this._worker.startJob();
+                nextTick(() => this.listen({ listen: this.config.listen }).finally(() => this._worker.endJob()));
+            }
         }
-        this.ready = true;
-        this._upgrade(key, headers);
     }
-    _upgrade(key, headers = []) {
-        const digest = crypto.createHash('sha1')
-            .update(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
-            .digest('base64');
-        headers = [
-            'HTTP/1.1 101 Switching Protocols',
-            'Upgrade: websocket',
-            'Connection: Upgrade',
-            `Sec-WebSocket-Accept: ${digest}`,
-            ...headers,
-            '',
-            ''
-        ];
-        this._socket.write(headers.join('\r\n'));
-        this._socket.on('error', this._errorHandler.bind(this));
-        this._socket.on('data', this._dataHandler.bind(this));
-        this._socket.on('close', () => this.emit('close'));
-        this._socket.on('end', () => this.emit('end'));
+    on(event, listener) {
+        if (event === 'ready' && this.isReady)
+            listener();
+        super.on(event, listener);
+        return this;
     }
-    /** Close connection */
-    close(reason, data) {
-        if (reason !== undefined) {
-            const buffer = Buffer.alloc(2 + (data ? data.length : 0));
-            buffer.writeUInt16BE(reason, 0);
-            if (data)
-                data.copy(buffer, 2);
-            data = buffer;
-        }
-        return this._sendFrame(0x88, data || EMPTY_BUFFER, () => this._socket.destroy());
+    addListener(event, listener) { return super.addListener(event, listener); }
+    once(event, listener) {
+        if (event === 'ready' && this.isReady)
+            listener();
+        else
+            super.once(event, listener);
+        return this;
     }
-    /** Generate WebSocket frame from data */
-    static getFrame(data, options) {
-        let msgType = 8;
-        let dataLength = 0;
-        if (typeof data === 'string') {
-            msgType = 1;
-            dataLength = Buffer.byteLength(data, 'utf8');
-        }
-        else if (data instanceof Buffer) {
-            msgType = 2;
-            dataLength = data.length;
-        }
-        else if (typeof data === 'number') {
-            msgType = data;
+    off(event, listener) { return super.off(event, listener); }
+    removeListener(event, listener) { return super.removeListener(event, listener); }
+    get isReady() {
+        return !this._worker.isBusy();
+    }
+    async waitReady() {
+        if (this.isReady)
+            return;
+        return this._worker.wait();
+    }
+    /** Listen server, should be used only if config.listen is not set */
+    async listen(config) {
+        if (!config && this.config.listen) {
+            console.debug('listen automatically started from constructor');
+            return;
         }
-        const headerSize = 2 + (dataLength < 126 ? 0 : dataLength < 65536 ? 2 : 8) + (dataLength && options?.mask ? 4 : 0);
-        const frame = Buffer.allocUnsafe(headerSize + dataLength);
-        frame[0] = 0x80 | msgType;
-        frame[1] = dataLength > 65535 ? 127 : dataLength > 125 ? 126 : dataLength;
-        if (dataLength > 65535)
-            frame.writeBigUInt64BE(dataLength, 2);
-        else if (dataLength > 125)
-            frame.writeUInt16BE(dataLength, 2);
-        if (dataLength && frame.length > dataLength) {
-            if (typeof data === 'string')
-                frame.write(data, headerSize, 'utf8');
-            else
-                data.copy(frame, headerSize);
+        if (!config)
+            throw new Error('listen config is required');
+        const listen = (config?.listen || this.config.listen || 0) + '';
+        const handler = config?.handler || this.handler.bind(this);
+        const tlsConfig = config ? config.tls : this.config.tls;
+        const readFile = (data) => data && (data.indexOf('\n') > 0 ? data : fs.readFileSync(data));
+        function tlsOptions() {
+            return {
+                cert: readFile(tlsConfig?.cert),
+                key: readFile(tlsConfig?.key),
+                ca: readFile(tlsConfig?.ca)
+            };
         }
-        if (dataLength && options?.mask) {
-            let i = headerSize, h = headerSize - 4;
-            for (let i = 0; i < 4; i++)
-                frame[h + i] = Math.floor(Math.random() * 256);
-            for (let j = 0; j < dataLength; j++, i++) {
-                frame[i] ^= frame[h + (j & 3)];
+        function tlsOptionsReload(srv) {
+            if (tlsConfig?.cert && tlsConfig.cert.indexOf('\n') < 0) {
+                let debounce;
+                fs.watch(tlsConfig.cert, () => {
+                    clearTimeout(debounce);
+                    debounce = setTimeout(() => {
+                        debounce = undefined;
+                        srv.setSecureContext(tlsOptions());
+                    }, 2000);
+                });
             }
         }
-        return frame;
-    }
-    /** Send data */
-    send(data) {
-        let msgType = typeof data === 'string' ? 1 : 2;
-        if (typeof data === 'string')
-            data = Buffer.from(data, 'utf8');
-        if (this._options.deflate && data.length > 256) {
-            const output = [];
-            const deflate = zlib.createDeflateRaw({
-                windowBits: this._options.maxWindowBits
+        const reg = /^((?<proto>\w+):\/\/)?(?<host>(\[[^\]]+\]|[a-z][^:,]+|\d+\.\d+\.\d+\.\d+))?:?(?<port>\d+)?/;
+        listen.split(',').forEach(listen => {
+            this._worker.startJob('listen');
+            let { proto, host, port } = reg.exec(listen)?.groups || {};
+            let srv;
+            switch (proto) {
+                case 'tcp':
+                    if (!config?.handler)
+                        throw new Error('Handler is required for tcp');
+                    srv = net.createServer(config.handler);
+                    break;
+                case 'tls':
+                    if (!config?.handler)
+                        throw new Error('Handler is required for tls');
+                    srv = tls.createServer(tlsOptions(), config.handler);
+                    tlsOptionsReload(srv);
+                    break;
+                case 'https':
+                    port = port || '443';
+                    srv = https.createServer(tlsOptions(), handler);
+                    tlsOptionsReload(srv);
+                    break;
+                default:
+                    port = port || '80';
+                    srv = http.createServer(handler);
+                    break;
+            }
+            if (!this.servers)
+                this.servers = new Set();
+            if (!this.sockets)
+                this.sockets = new Set();
+            this.servers.add(srv);
+            if (port === '0') // skip listening
+                this._worker.endJob('listen');
+            else {
+                srv.listen(parseInt(port), host?.replace(/[\[\]]/g, '') || '0.0.0.0', () => {
+                    const addr = srv.address();
+                    this.emit('listen', addr.port, addr.address, srv);
+                    srv._ready = true;
+                    this._worker.endJob('listen');
+                });
+            }
+            srv.on('error', err => {
+                srv.close();
+                this.servers.delete(srv);
+                if (!srv._ready)
+                    this._worker.endJob('listen');
+                this.emit('error', err);
             });
-            deflate.write(data);
-            deflate.on('data', (chunk) => output.push(chunk));
-            deflate.flush(() => {
-                if (output.length > 0 && output[output.length - 1].length > 4)
-                    output[output.length - 1] = output[output.length - 1].subarray(0, output[output.length - 1].length - 4);
-                this._sendFrame(0xC0 | msgType, Buffer.concat(output));
+            srv.on('connection', s => {
+                this.sockets.add(s);
+                s.once('close', () => this.sockets.delete(s));
             });
-        }
-        else
-            return this._sendFrame(0x80 | msgType, data);
-    }
-    _errorHandler(error) {
-        this.emit('error', error);
-        if (this.ready)
-            this.close(error instanceof WebSocketError && error.statusCode || 1002);
-        else
-            this._socket.destroy();
-        this.ready = false;
+        });
+        return this._worker.wait('listen');
     }
-    _headerLength(buffer) {
-        if (this._frame)
-            return 0;
-        if (!buffer || buffer.length < 2)
-            return 2;
-        let hederInfo = buffer[1];
-        return 2 + (hederInfo & 0x80 ? 4 : 0) + ((hederInfo & 0x7F) === 126 ? 2 : 0) + ((hederInfo & 0x7F) === 127 ? 8 : 0);
-    }
-    _dataHandler(data) {
-        while (data.length) {
-            let frame = this._frame;
-            if (!frame) {
-                let lastBuffer = this._buffers[this._buffers.length - 1];
-                this._buffers[this._buffers.length - 1] = lastBuffer = Buffer.concat([lastBuffer, data]);
-                let headerLength = this._headerLength(lastBuffer);
-                if (lastBuffer.length < headerLength)
-                    return;
-                const headerBits = lastBuffer[0];
-                const lengthBits = lastBuffer[1] & 0x7F;
-                this._buffers.pop();
-                data = lastBuffer.subarray(headerLength);
-                // parse header
-                frame = this._frame = {
-                    fin: (headerBits & 0x80) !== 0,
-                    rsv1: (headerBits & 0x40) !== 0,
-                    opcode: headerBits & 0x0F,
-                    mask: (lastBuffer[1] & 0x80) ? lastBuffer.subarray(headerLength - 4, headerLength) : EMPTY_BUFFER,
-                    length: lengthBits === 126 ? lastBuffer.readUInt16BE(2) : lengthBits === 127 ? lastBuffer.readBigUInt64BE(2) : lengthBits,
-                    lengthReceived: 0,
-                    index: this._buffers.length
-                };
-            }
-            let toRead = frame.length - frame.lengthReceived;
-            if (toRead > data.length)
-                toRead = data.length;
-            if (this._options.maxPayload && this._options.maxPayload < this._buffersLength + frame.length) {
-                this._errorHandler(new WebSocketError('Payload too big', 1009));
-                return;
-            }
-            // unmask
-            for (let i = 0, j = frame.lengthReceived; i < toRead; i++, j++)
-                data[i] ^= frame.mask[j & 3];
-            frame.lengthReceived += toRead;
-            if (frame.lengthReceived < frame.length) {
-                this._buffers.push(data);
-                return;
+    /** bind middleware or create one from string like: 'redirect:302,https://redirect.to', 'error:422', 'param:name=value', 'acl:users/get', 'model:User', 'group:Users', 'user:admin' */
+    _bind(fn) {
+        if (typeof fn === 'string') {
+            let name = fn;
+            let idx = name.indexOf(':');
+            if (idx < 0 && name.includes('=')) {
+                name = 'param:' + name;
+                idx = 5;
             }
-            this._buffers.push(data.subarray(0, toRead));
-            this._buffersLength += toRead;
-            data = data.subarray(toRead);
-            if (frame.opcode >= 8) {
-                const message = Buffer.concat(this._buffers.splice(frame.index));
-                switch (frame.opcode) {
-                    case 8:
-                        if (!frame.length)
-                            this.emit('close');
-                        else {
-                            const code = message.readInt16BE(0);
-                            if (frame.length === 2)
-                                this.emit('close', code);
-                            else
-                                this.emit('close', code, message.subarray(2));
-                        }
-                        this._socket.destroy();
-                        return;
-                    case 9:
-                        if (message.length)
-                            this.emit('ping', message);
-                        else
-                            this.emit('ping');
-                        if (this._options.autoPong)
-                            this.pong(message);
-                        break;
-                    case 10:
-                        if (message.length)
-                            this.emit('pong', message);
-                        else
-                            this.emit('pong');
+            if (idx >= 0) {
+                const v = name.slice(idx + 1);
+                const type = name.slice(0, idx);
+                // predefined middlewares
+                switch (type) {
+                    case 'response': {
+                        if (v === 'json')
+                            return (req, res, next) => { res.isJson = true; return next(); };
+                        if (v === 'html')
+                            return (req, res, next) => { res.setHeader('Content-Type', 'text/html'); return next(); };
+                        if (v === 'end')
+                            return (req, res, next) => { res.end(); };
                         break;
-                    default:
-                        return this._errorHandler(new WebSocketError('Invalid WebSocket frame'));
-                }
-            }
-            else if (frame.fin) {
-                if (!frame.opcode)
-                    return this._errorHandler(new WebSocketError('Invalid WebSocket frame'));
-                if (this._options.deflate && frame.rsv1) {
-                    const output = [];
-                    const inflate = zlib.createInflateRaw({
-                        windowBits: this._options.maxWindowBits
-                    });
-                    inflate.on('data', (chunk) => output.push(chunk));
-                    inflate.on('error', (err) => this._errorHandler(err));
-                    for (const buffer of this._buffers)
-                        inflate.write(buffer);
-                    inflate.write(DEFLATE_TRAILER);
-                    inflate.flush(() => {
-                        if (this.ready) {
-                            const message = Buffer.concat(output);
-                            this.emit('message', frame.opcode === 1 ? message.toString('utf8') : message);
+                    }
+                    // redirect:302,https://redirect.to
+                    case 'redirect': {
+                        let redirect = v.split(','), code = parseInt(v[0]);
+                        if (!code || code < 301 || code > 399)
+                            code = 302;
+                        return (req, res) => res.redirect(code, redirect[1] || v);
+                    }
+                    // error:422
+                    case 'error':
+                        return (req, res) => res.error(parseInt(v) || 422);
+                    // param:name=value
+                    case 'param': {
+                        idx = v.indexOf('=');
+                        if (idx > 0) {
+                            const prm = v.slice(0, idx), val = v.slice(idx + 1);
+                            return (req, res, next) => { req.params[prm] = val; return next(); };
                         }
-                    });
-                }
-                else {
-                    const message = Buffer.concat(this._buffers);
-                    this.emit('message', frame.opcode === 1 ? message.toString('utf8') : message);
+                        break;
+                    }
+                    case 'model': {
+                        const model = v;
+                        return (req, res) => {
+                            res.isJson = true;
+                            req.params.model = model;
+                            req.model = Model.models[model];
+                            if (!req.model) {
+                                console.error(`Data model ${model} not defined for request ${req.path}`);
+                                return res.error(422);
+                            }
+                            return req.model.handler(req, res);
+                        };
+                    }
+                    // user:userid
+                    // group:user_groupid
+                    // acl:validacl
+                    case 'user':
+                    case 'group':
+                    case 'acl':
+                        return (req, res, next) => {
+                            if (type === 'user' && v === req.user?.id)
+                                return next();
+                            if (type === 'acl') {
+                                req.params.acl = v;
+                                if (req.auth?.acl(v))
+                                    return next();
+                            }
+                            if (type === 'group') {
+                                req.params.group = v;
+                                if (req.user?.group === v)
+                                    return next();
+                            }
+                            const accept = req.headers.accept || '';
+                            if (!res.isJson && req.auth?.options.redirect && req.method === 'GET' && !accept.includes('json') && (accept.includes('html') || accept.includes('*/*'))) {
+                                if (req.auth.options.redirect && req.url !== req.auth.options.redirect)
+                                    return res.redirect(302, req.auth.options.redirect);
+                                else if (req.auth.options.mode !== 'cookie') {
+                                    res.setHeader('WWW-Authenticate', `Basic realm="${req.auth.options.realm}"`);
+                                    return res.error(401);
+                                }
+                            }
+                            return res.error('Permission denied');
+                        };
                 }
-                this._buffers = [];
-                this._buffersLength = 0;
             }
-            this._frame = undefined;
-            this._buffers.push(EMPTY_BUFFER);
+            throw new Error('Invalid option: ' + name);
         }
+        if (fn && typeof fn === 'object' && 'handler' in fn && typeof fn.handler === 'function')
+            return fn.handler.bind(fn);
+        if (typeof fn !== 'function')
+            throw new Error('Invalid middleware: ' + String.toString.call(fn));
+        return fn.bind(this);
     }
-    _abort(message, code, headers) {
-        code = code || 400;
-        message = message || http.STATUS_CODES[code] || 'Closed';
-        headers = [
-            `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}`,
-            'Connection: close',
-            'Content-Type: ' + message.startsWith('<') ? 'text/html' : 'text/plain',
-            `Content-Length: ${Buffer.byteLength(message)}`,
-            '',
-            message
-        ];
-        this._socket.once('finish', () => {
-            this._socket.destroy();
-            this.emit('close');
-        });
-        this._socket.end(headers.join('\r\n'));
-        this.emit('error', new Error(message));
+    /** Default server handler */
+    handler(req, res) {
+        ServerRequest.extend(req, this);
+        ServerResponse.extend(res);
+        if (req.readable) {
+            req._isReady = deferPromise((err) => {
+                req._isReady = undefined;
+                if (err) {
+                    if (!res.headersSent)
+                        res.error('statusCode' in err ? err.statusCode : 400);
+                }
+            });
+        }
+        this._router.walk(this._stack, req, res, () => res.error(404));
+        //this.handlerRouter(req, res, () => this.handlerLast(req, res))
     }
-    /** Send ping frame */
-    ping(buffer) {
-        this._sendFrame(0x89, buffer || EMPTY_BUFFER);
+    /** Last request handler */
+    handlerLast(req, res, next) {
+        if (res.headersSent || res.closed)
+            return;
+        if (!next)
+            next = () => res.error(404);
+        return next();
     }
-    /** Send pong frame */
-    pong(buffer) {
-        this._sendFrame(0x8A, buffer || EMPTY_BUFFER);
+    /** Clear routes and middlewares */
+    clear() {
+        this._stack = [];
+        this._router.clear();
+        this._plugin(this._router);
+        return this;
     }
-    _sendFrame(opcode, data, cb) {
-        if (!this.ready)
+    /**
+     * Add middleware route.
+     * Middlewares may return promises for res.jsonSuccess(...), throw errors for res.error(...), return string or {} for res.send(...)
+     * RouteURL: 'METHOD /suburl', 'METHOD', '* /suburl'
+     */
+    async use(...args) {
+        if (!args[0])
             return;
-        const dataLength = data.length;
-        const headerSize = 2 + (dataLength < 126 ? 0 : dataLength < 65536 ? 2 : 8);
-        const frame = Buffer.allocUnsafe(headerSize + (dataLength < 4096 ? dataLength : 0));
-        frame[0] = opcode;
-        frame[1] = dataLength > 65535 ? 127 : dataLength > 125 ? 126 : dataLength;
-        if (dataLength > 65535)
-            frame.writeBigUInt64BE(dataLength, 2);
-        else if (dataLength > 125)
-            frame.writeUInt16BE(dataLength, 2);
-        if (dataLength && frame.length > dataLength) {
-            data.copy(frame, headerSize);
-            this._socket.write(frame, cb);
+        this._worker.startJob();
+        for (let i = 0; i < args.length; i++)
+            if (args[i] instanceof Promise)
+                args[i] = await args[i];
+        // use(plugin)
+        if (args[0] instanceof Plugin) {
+            await this._plugin(args[0]);
+            return this._worker.endJob();
         }
-        else
-            this._socket.write(frame, () => this._socket.write(data, cb));
+        // use(PluginClass, options?: any)
+        if (typeof args[0] === 'function' && args[0].prototype instanceof Plugin) {
+            const pluginid = args[0].name.toLowerCase().replace(/plugin$/, '');
+            const plugin = new args[0](args[1] || this.config[pluginid], this);
+            await this._plugin(plugin);
+            return this._worker.endJob();
+        }
+        // use(middleware)
+        if (isFunction(args[0])) {
+            this.addStack(args[0]);
+            return this._worker.endJob();
+        }
+        let method = '*', url = '/';
+        if (typeof args[0] === 'string') {
+            const m = args[0].match(/^([A-Z]+) (.*)/);
+            if (m)
+                [method, url] = [m[1], m[2]];
+            else
+                url = args[0];
+            if (!url.startsWith('/'))
+                throw new Error(`Invalid url ${url}`);
+            args = args.slice(1);
+        }
+        let routes = args[0];
+        // use('/url', ControllerClass)
+        if (typeof args[0] === 'function' && args[0].prototype instanceof Controller) {
+            routes = args[0].routes();
+        }
+        // use('/url', [ ['METHOD /url', ...], {'METHOD } ])
+        if (Array.isArray(routes)) {
+            if (method !== '*')
+                throw new Error('Invalid router usage');
+            for (const item of routes) {
+                if (Array.isArray(item)) {
+                    // [methodUrl, ...middlewares]
+                    if (typeof item[0] !== 'string' || !item[0].match(/^(\w+ )?\//))
+                        throw new Error('Url expected');
+                    await this.use(item[0].replace(/\//, (url === '/' ? '' : url) + '/'), ...item.slice(1));
+                }
+                else
+                    throw new Error('Invalid param');
+            }
+            return this._worker.endJob();
+        }
+        // use('/url', {'METHOD /url': [...middlewares], ... } ])
+        if (typeof routes === 'object' && routes.constructor === Object) {
+            if (method !== '*')
+                throw new Error('Invalid router usage');
+            for (const [subUrl, subArgs] of Object.entries(args[0])) {
+                if (!subUrl.match(/^(\w+ )?\//))
+                    throw new Error('Url expected');
+                await this.use(subUrl.replace(/\//, (url === '/' ? '' : url) + '/'), ...(Array.isArray(subArgs) ? subArgs : [subArgs]));
+            }
+            return this._worker.endJob();
+        }
+        // use('/url', ...middleware)
+        this._router.add(method, url, args.filter(o => o).map((o) => this._bind(o)), true);
+        return this._worker.endJob();
     }
-}
-const server = {};
-/**
- * Controller for dynamic routes
- *
- * @example
- * ```js
- * class MyController extends Controller {
- *   static model = MyModel;
- *   static acl = 'auth';
- *
- *   static 'acl:index' = '';
- *   static 'url:index' = 'GET /index';
- *   async index (req, res) {
- *     res.send('Hello World')
- *   }
- *
- *   //function name prefixes translated to HTTP methods:
- *   //  all => GET, get => GET, insert => POST, post => POST,
- *   //  update => PUT, put => PUT, delete => DELETE,
- *   //  modify => PATCH, patch => PATCH,
- *   //  websocket => internal WebSocket
- *   // automatic acl will be: class_name + '/' + function_name_prefix
- *   // automatic url will be: method + ' /' + class_name + '/' + function_name_without_prefix
- *
- *   //static 'acl:allUsers' = 'MyController/all';
- *   //static 'url:allUsers' = 'GET /MyController/Users';
- *   async allUsers () {
- *     return ['usr1', 'usr2', 'usr3']
- *   }
- *
- *   //static 'acl:getOrder' = 'MyController/get';
- *   //static 'url:getOrder' = 'GET /Users/:id/:id1';
- *   static 'group:getOrder' = 'orders';
- *   static 'model:getOrder' = OrderModel;
- *   async getOrder (id: string, id1: string) {
- *     return {id, extras: id1, type: 'order'}
- *   }
- *
- *   //static 'acl:insertOrder' = 'MyController/insert';
- *   //static 'url:insertOrder' = 'POST /Users/:id';
- *   static 'model:insertOrder' = OrderModel;
- *   async insertOrder (id: string, id1: string) {
- *     return {id, extras: id1, type: 'order'}
- *   }
- *
- *   static 'acl:POST /login' = '';
- *   async 'POST /login' () {
- *     return {id, extras: id1, type: 'order'}
- *   }
- * }
- * ```
-*/
-export class Controller {
-    get model() {
-        return this.req.model;
+    async _plugin(plugin) {
+        if (plugin.handler) {
+            const middleware = plugin.handler.bind(plugin);
+            middleware.plugin = plugin;
+            middleware.priority = plugin.priority;
+            this.addStack(middleware);
+        }
+        if (plugin.routes) {
+            const routes = isFunction(plugin.routes) ? await plugin.routes() : plugin.routes;
+            if (routes)
+                await this.use(routes);
+        }
+        if (plugin.handler && plugin.name) {
+            this.emit('plugin', plugin.name);
+            this.emit('plugin:' + plugin.name);
+            this._worker.endJob('plugin:' + plugin.name);
+        }
     }
-    constructor(req, res) {
-        this.req = req;
-        this.res = res;
-        res.isJson = true;
+    addStack(middleware) {
+        if (middleware.plugin?.name && this.getPlugin(middleware.plugin.name))
+            throw new Error(`Plugin ${middleware.plugin.name} already added`);
+        const priority = middleware.priority || 0;
+        const idx = this._stack.findLastIndex(f => (f.priority || 0) <= priority);
+        this._stack.splice(idx + 1, 0, middleware);
     }
-    /** Generate routes for this controller */
-    static routes() {
-        const routes = [];
-        const prefix = Object.getOwnPropertyDescriptor(this, 'name')?.enumerable ? this.name + '/' : '';
-        // iterate throught decorators
-        Object.getOwnPropertyNames(this.prototype).forEach(key => {
-            if (key === 'constructor' || key.startsWith('_'))
-                return;
-            const func = this.prototype[key];
-            if (typeof func !== 'function')
-                return;
-            const thisStatic = this;
-            let url = thisStatic['url:' + key];
-            let acl = thisStatic['acl:' + key] ?? thisStatic['acl'];
-            const user = thisStatic['user:' + key] ?? thisStatic['user'];
-            const group = thisStatic['group:' + key] ?? thisStatic['group'];
-            const modelName = thisStatic['model:' + key] ?? thisStatic['model'];
-            let method = '';
-            if (!url)
-                key = key.replaceAll('$', '/');
-            if (!url && key.startsWith('/')) {
-                method = '*';
-                url = key;
-            }
-            let keyMatch = !url && key.match(/^(all|get|put|post|patch|insert|update|modify|delete|websocket)[/_]?([\w_/-]*)$/i);
-            if (keyMatch) {
-                method = keyMatch[1];
-                url = '/' + prefix + keyMatch[2];
-            }
-            keyMatch = !url && key.match(/^([*\w]+) (.+)$/);
-            if (keyMatch) {
-                method = keyMatch[1];
-                url = keyMatch[2].startsWith('/') ? keyMatch[2] : ('/' + prefix + keyMatch[1]);
-            }
-            keyMatch = !method && url?.match(/^([*\w]+) (.+)$/);
-            if (keyMatch) {
-                method = keyMatch[1];
-                url = keyMatch[2].startsWith('/') ? keyMatch[2] : ('/' + prefix + keyMatch[2]);
-            }
-            if (!method)
-                return;
-            let autoAcl = method.toLowerCase();
-            switch (autoAcl) {
-                case '*':
-                    autoAcl = '';
-                    break;
-                case 'post':
-                    autoAcl = 'insert';
-                    break;
-                case 'put':
-                    autoAcl = 'update';
-                    break;
-                case 'patch':
-                    autoAcl = 'modify';
-                    break;
-            }
-            method = method.toUpperCase();
-            switch (method) {
-                case '*':
-                    break;
-                case 'GET':
-                case 'POST':
-                case 'PUT':
-                case 'PATCH':
-                case 'DELETE':
-                case 'WEBSOCKET':
-                    break;
-                case 'ALL':
-                    method = 'GET';
-                    break;
-                case 'INSERT':
-                    method = 'POST';
-                    break;
-                case 'UPDATE':
-                    method = 'PUT';
-                    break;
-                case 'MODIFY':
-                    method = 'PATCH';
-                    break;
-                default:
-                    throw new Error('Invalid url method for: ' + key);
-            }
-            if (user === undefined && group === undefined && acl === undefined)
-                acl = prefix + autoAcl;
-            // add params if not available in url
-            if (func.length && !url.includes(':')) {
-                let args = ['/:id'];
-                for (let i = 1; i < func.length; i++)
-                    args.push('/:id' + i);
-                url += args.join('');
-            }
-            const list = [method + ' ' + url.replace(/\/\//g, '/')];
-            if (acl)
-                list.push('acl:' + acl);
-            if (user)
-                list.push('user:' + user);
-            if (group)
-                list.push('group:' + group);
-            list.push((req, res) => {
-                res.isJson = true;
-                const obj = new this(req, res);
-                if (modelName) {
-                    req.model = modelName instanceof Model ? modelName : Model.models[modelName];
-                    if (!obj.model)
-                        throw new InvalidData(modelName, 'model');
-                    req.model = Model.dynamic(req.model, { controller: obj });
-                }
-                return func.apply(obj, req.paramsList);
-            });
-            routes.push(list);
-        });
-        return routes;
+    getPlugin(id) {
+        let p = this._stack.find(m => m.plugin?.name === id);
+        return p?.plugin;
     }
-}
-class WaiterJob {
-    constructor() {
-        this._waiters = [];
-        this._busy = 0;
+    async waitPlugin(id) {
+        const p = this.getPlugin(id);
+        if (p)
+            return p;
+        this._worker.startJob('plugin:' + id);
+        await this._worker.wait('plugin:' + id);
+        return this.getPlugin(id);
     }
-    start() {
-        this._busy++;
+    /** Add route, alias to `server.router.use(url, ...args)` */
+    all(url, ...args) {
+        this.use('* ' + url, ...args);
+        return this;
     }
-    end() {
-        this._busy--;
-        for (const resolve of this._waiters.splice(0))
-            resolve();
+    /** Add route, alias to `server.router.use('GET ' + url, ...args)` */
+    get(url, ...args) {
+        this.use('GET ' + url, ...args);
+        return this;
     }
-    async wait() {
-        if (!this._busy)
-            return;
-        return new Promise(resolve => this._waiters.push(resolve));
+    /** Add route, alias to `server.router.use('POST ' + url, ...args)` */
+    post(url, ...args) {
+        this.use('POST ' + url, ...args);
+        return this;
     }
-}
-class Waiter {
-    constructor() {
-        this._id = 0;
-        this._waiters = {};
+    /** Add route, alias to `server.router.use('PUT ' + url, ...args)` */
+    put(url, ...args) {
+        this.use('PUT ' + url, ...args);
+        return this;
     }
-    isBusy(id) {
-        const waiter = this._waiters[id || 'ready'];
-        return !!waiter?._busy;
+    /** Add route, alias to `server.router.use('PATCH ' + url, ...args)` */
+    patch(url, ...args) {
+        this.use('PATCH ' + url, ...args);
+        return this;
     }
-    startJob(id) {
-        let waiter = this._waiters[id || 'ready'];
-        if (!waiter)
-            waiter = this._waiters[id || 'ready'] = new WaiterJob();
-        waiter._busy++;
+    /** Add route, alias to `server.router.use('DELETE ' + url, ...args)` */
+    delete(url, ...args) {
+        this.use('DELETE ' + url, ...args);
+        return this;
     }
-    endJob(id) {
-        const waiter = this._waiters[id || 'ready'];
-        if (waiter)
-            waiter.end();
+    /** Add websocket handler, alias to `server.router.use('WEBSOCKET ' + url, ...args)` */
+    websocket(url, ...args) {
+        this.use('WEBSOCKET ' + url, ...args);
+        return this;
     }
-    get nextId() {
-        return (++this._id).toString();
+    /** Add router hook, alias to `server.router.hook(url, ...args)` */
+    hook(url, ...args) {
+        const m = url.match(/^([A-Z]+) (.*)/) || ['', 'hook', url];
+        this._router.add(m[1], m[2], args.filter(m => m).map(m => this._bind(m)), false);
+        return this;
     }
-    async wait(id) {
-        const waiter = this._waiters[id || 'ready'];
-        if (!waiter)
-            return;
-        return waiter.wait();
+    /** Check if middleware allready added */
+    has(mid) {
+        const check = (stack) => stack.includes(mid) || (mid.name && !!stack.find(f => f.name === mid.name)) || false;
+        return check(this._stack);
+    }
+    async close() {
+        this._worker.startJob('close');
+        this.servers?.forEach(srv => {
+            this._worker.startJob('close');
+            srv.close(() => this._worker.endJob('close'));
+        });
+        this.servers?.clear();
+        this.sockets?.forEach(s => {
+            if (s.readyState !== 'closed') {
+                this._worker.startJob('close');
+                s.once('close', () => this._worker.endJob('close'));
+                s.destroy();
+            }
+        });
+        this.sockets?.clear();
+        this._worker.endJob('close');
+        await this._worker.wait('close');
+        this.emit('close');
     }
 }
-/** Router */
-export class Router extends EventEmitter {
-    /** @param {MicroServer} server  */
-    constructor(server) {
+// #region RouterPlugin
+class RouterItem {
+    _stack; // add if middlewares added if not last
+    _next; // next middlewares
+    _paramName; // param name if param is used
+    _paramWild;
+    _withParam; // next middlewares if param is used
+    _last;
+}
+class RouterPlugin extends Plugin {
+    priority = 100;
+    name = 'router';
+    //stack: Middleware[] = []
+    _tree = {};
+    constructor() {
         super();
-        this.plugins = {};
-        this._stack = [];
-        this._stackAfter = [];
-        this._tree = {};
-        this._waiter = new Waiter();
-        this.server = server;
     }
-    /** bind middleware or create one from string like: 'redirect:302,https://redirect.to', 'error:422', 'param:name=value', 'acl:users/get', 'model:User', 'group:Users', 'user:admin' */
-    bind(fn) {
-        if (typeof fn === 'string') {
-            let name = fn;
-            let idx = name.indexOf(':');
-            if (idx < 0 && name.includes('=')) {
-                name = 'param:' + name;
-                idx = 5;
-            }
-            if (name === 'json')
-                return (req, res, next) => { res.isJson = true; return next(); };
-            if (idx >= 0) {
-                const v = name.slice(idx + 1);
-                const type = name.slice(0, idx);
-                // predefined middlewares
-                switch (type) {
-                    // redirect:302,https://redirect.to
-                    case 'redirect': {
-                        let redirect = v.split(','), code = parseInt(v[0]);
-                        if (!code || code < 301 || code > 399)
-                            code = 302;
-                        return (req, res) => res.redirect(code, redirect[1] || v);
-                    }
-                    // error:422
-                    case 'error':
-                        return (req, res) => res.error(parseInt(v) || 422);
-                    // param:name=value
-                    case 'param': {
-                        idx = v.indexOf('=');
-                        if (idx > 0) {
-                            const prm = v.slice(0, idx), val = v.slice(idx + 1);
-                            return (req, res, next) => { req.params[prm] = val; return next(); };
-                        }
-                        break;
+    add(treeItem, path, middlewares, last) {
+        middlewares = middlewares.filter(m => m);
+        if (!middlewares.length)
+            return;
+        let node = this._tree[treeItem];
+        if (!node)
+            this._tree[treeItem] = node = {};
+        if (path && path !== '/') {
+            const segments = path.split('/').filter(s => s);
+            for (let i = 0; i < segments.length; i++) {
+                const seg = segments[i];
+                if (seg[0] === ':') {
+                    const isWild = seg.endsWith('*');
+                    const paramName = isWild ? seg.slice(1, -1) : seg.slice(1);
+                    if (!node._withParam) {
+                        node._withParam = { _paramName: paramName, _paramWild: isWild };
                     }
-                    case 'model': {
-                        const model = v;
-                        return (req, res) => {
-                            res.isJson = true;
-                            req.params.model = model;
-                            req.model = Model.models[model];
-                            if (!req.model) {
-                                console.error(`Data model ${model} not defined for request ${req.path}`);
-                                return res.error(422);
-                            }
-                            return req.model.handler(req, res);
-                        };
+                    else {
+                        if (node._withParam._paramName !== paramName)
+                            throw new Error(`Router param already used: ${node._withParam._paramName} != ${paramName}`);
+                        if (isWild)
+                            node._withParam._paramWild = true;
                     }
-                    // user:userid
-                    // group:user_groupid
-                    // acl:validacl
-                    case 'user':
-                    case 'group':
-                    case 'acl':
-                        return (req, res, next) => {
-                            if (type === 'user' && v === req.user?.id)
-                                return next();
-                            if (type === 'acl') {
-                                req.params.acl = v;
-                                if (req.auth?.acl(v))
-                                    return next();
-                            }
-                            if (type === 'group') {
-                                req.params.group = v;
-                                if (req.user?.group === v)
-                                    return next();
-                            }
-                            const accept = req.headers.accept || '';
-                            if (!res.isJson && req.auth?.options.redirect && req.method === 'GET' && !accept.includes('json') && (accept.includes('html') || accept.includes('*/*'))) {
-                                if (req.auth.options.redirect && req.url !== req.auth.options.redirect)
-                                    return res.redirect(302, req.auth.options.redirect);
-                                else if (req.auth.options.mode !== 'cookie') {
-                                    res.setHeader('WWW-Authenticate', `Basic realm="${req.auth.options.realm}"`);
-                                    return res.error(401);
-                                }
-                            }
-                            return res.error('Permission denied');
-                        };
+                    node = node._withParam;
+                    if (isWild)
+                        break;
+                }
+                else {
+                    if (!node._next)
+                        node._next = {};
+                    if (!node._next[seg])
+                        node._next[seg] = { _next: {} };
+                    node = node._next[seg];
                 }
             }
-            throw new Error('Invalid option: ' + name);
         }
-        if (fn && typeof fn === 'object' && 'handler' in fn && typeof fn.handler === 'function')
-            return fn.handler.bind(fn);
-        if (typeof fn !== 'function')
-            throw new Error('Invalid middleware: ' + String.toString.call(fn));
-        return fn.bind(this);
+        if (last) {
+            node._last ||= [];
+            node._last.push(...middlewares);
+        }
+        else {
+            node._stack ||= [];
+            node._stack.push(...middlewares);
+        }
     }
-    /** Handler */
-    handler(req, res, next, method) {
-        const nextAfter = next;
-        next = () => this._walkStack(this._stackAfter, req, res, nextAfter);
-        const walkTree = (method) => this._walkTree(this._tree[method], req, res, next);
-        const walk = method ?
-            () => { !walkTree(method) && next(); } :
-            () => { !walkTree(req.method || 'GET') && !walkTree('*') && next(); };
-        req.rewrite = (url) => {
-            if (req.originalUrl)
-                res.error(508);
-            req.updateUrl(url);
-            walk();
-        };
-        this._walkStack(this._stack, req, res, walk);
+    _getStack(path, treeItems) {
+        const out = [];
+        const segments = path.split('/').filter(s => s);
+        for (const key of treeItems) {
+            let node = this._tree[key];
+            if (!node)
+                continue;
+            for (let i = 0; i < segments.length && node; i++) {
+                const seg = segments[i];
+                if (node._stack)
+                    out.push(...node._stack);
+                // static match
+                if (node._next?.[seg]) {
+                    node = node._next[seg];
+                    continue;
+                }
+                // param match
+                if (node._withParam) {
+                    const paramNode = node._withParam;
+                    const value = decodeURIComponent(paramNode._paramWild ? segments.slice(i).join('/') : seg), name = paramNode._paramName;
+                    out.push((req, res, next) => { req.params[name] = value; req.paramsList.push(value); next(); });
+                    node = paramNode;
+                    if (paramNode._paramWild)
+                        break;
+                    else
+                        continue;
+                }
+                node = undefined;
+            }
+            if (node?._stack)
+                out.push(...node._stack);
+            if (node?._last) {
+                out.push(...node._last);
+                return out;
+            }
+        }
+        return out;
     }
-    _walkStack(rstack, req, res, next) {
-        let rnexti = 0;
+    walk(stack, req, res, next) {
         const sendData = (data) => {
-            if (!res.headersSent && data !== undefined) {
+            if (!res.headersSent && !res.closed && data !== undefined) {
                 if ((data === null || typeof data === 'string') && !res.isJson)
                     return res.send(data);
                 if (typeof data === 'object' &&
-                    (data instanceof Buffer || data instanceof Readable || (data instanceof Error && !res.isJson)))
+                    (data instanceof Buffer || data instanceof Readable || data instanceof Error))
                     return res.send(data);
                 return res.jsonSuccess(data);
             }
         };
-        const rnext = () => {
-            const cb = rstack[rnexti++];
-            if (cb) {
-                try {
-                    req.router = this;
-                    const p = cb(req, res, rnext);
-                    if (p instanceof Promise)
-                        p.catch(e => e).then(sendData);
-                    else
-                        sendData(p);
-                }
-                catch (e) {
-                    sendData(e);
-                }
-            }
-            else
+        let idx = 0;
+        const callNext = () => {
+            if (res.headersSent || res.closed)
+                return;
+            const fn = stack[idx++];
+            if (!fn)
                 return next();
+            try {
+                const r = fn(req, res, callNext);
+                if (r instanceof Promise)
+                    r.catch(e => e).then(sendData);
+                else
+                    sendData(r);
+            }
+            catch (e) {
+                sendData(e);
+            }
         };
-        return rnext();
-    }
-    _walkTree(item, req, res, next) {
-        req.params = {};
-        req.paramsList = [];
-        const rstack = [];
-        const reg = /\/([^/]*)/g;
-        let m;
-        let lastItem, done;
-        while (m = reg.exec(req.pathname)) {
-            const name = m[1];
-            if (!item || done) {
-                item = undefined;
-                break;
-            }
-            if (lastItem !== item) {
-                lastItem = item;
-                item.hook?.forEach((hook) => rstack.push(hook.bind(item)));
-            }
-            if (!item.tree) { // last
-                if (item.name) {
-                    req.params[item.name] += '/' + name;
-                    req.paramsList[req.paramsList.length - 1] = req.params[item.name];
+        return callNext();
+    }
+    clear() {
+        this._tree = {};
+    }
+    handler(req, res, next) {
+        this.walk(this._getStack(req.pathname, ['hook', req.method, '*']), req, res, next);
+    }
+}
+export class CorsPlugin extends Plugin {
+    priority = -100;
+    name = 'cors';
+    options;
+    constructor(options) {
+        super();
+        if (!options) {
+            this.handler = undefined;
+            return;
+        }
+        if (options === true)
+            options = '*';
+        this.options = typeof options === 'string' ? { origin: options, headers: 'Content-Type', credentials: true } : options;
+    }
+    handler(req, res, next) {
+        if (this.options && req.headers.origin) {
+            const cors = this.options;
+            if (cors.origin)
+                res.setHeader('Access-Control-Allow-Origin', cors.origin);
+            if (cors.headers)
+                res.setHeader('Access-Control-Allow-Headers', cors.headers);
+            if (cors.credentials)
+                res.setHeader('Access-Control-Allow-Credentials', 'true');
+            if (cors.expose)
+                res.setHeader('Access-Control-Expose-Headers', cors.expose);
+            if (cors.maxAge)
+                res.setHeader('Access-Control-Max-Age', cors.maxAge);
+        }
+        return next();
+    }
+}
+// #enregion CorsPlugin
+// #region MethodsPlugin
+export class MethodsPlugin extends Plugin {
+    priority = -90;
+    name = 'methods';
+    _methods;
+    _methodsIdx;
+    constructor(methods) {
+        super();
+        this._methods = methods || defaultMethods;
+        this._methodsIdx = this._methods.split(',').reduce((acc, m) => (acc[m] = true, acc), {});
+    }
+    handler(req, res, next) {
+        if (req.method === 'GET' || req.headers.upgrade)
+            return next();
+        if (req.method === 'OPTIONS') {
+            res.setHeader('Allow', this._methods);
+            return res.status(204).end();
+        }
+        if (!req.method || !this._methodsIdx?.[req.method]) {
+            res.setHeader('Allow', this._methods);
+            return res.status(405).end();
+        }
+        if (req.method === 'HEAD') {
+            req.method = 'GET';
+            res.headersOnly = true;
+        }
+        return next();
+    }
+}
+export class BodyPlugin extends Plugin {
+    priority = -80;
+    name = 'body';
+    _maxBodySize;
+    constructor(options) {
+        super();
+        this._maxBodySize = options?.maxBodySize || defaultMaxBodySize;
+    }
+    handler(req, res, next) {
+        if (req.complete || req.method === 'GET') {
+            if (!req.body)
+                req._body = {};
+            return next();
+        }
+        req._isReady = deferPromise((err) => {
+            req._isReady = undefined;
+            if (err) {
+                if (!req.complete)
+                    req.pause();
+                if (!res.headersSent)
+                    res.error('statusCode' in err ? err.statusCode : 400);
+            }
+            else if (req.complete)
+                res.removeHeader('Connection');
+        });
+        const contentType = req.headers['content-type'] || '';
+        if (contentType.startsWith('multipart/form-data')) {
+            req.pause();
+            res.setHeader('Connection', 'close');
+            return next();
+        }
+        if (parseInt(req.headers['content-length'] || '-1') > this._maxBodySize) {
+            return req._isReady?.resolve(new ResponseError("too big", 413));
+        }
+        req.once('error', () => { })
+            .on('data', chunk => {
+            req.rawBodySize += chunk.length;
+            if (req.rawBodySize >= this._maxBodySize)
+                req._isReady?.resolve(new ResponseError("too big", 413));
+            else
+                req.rawBody.push(chunk);
+        })
+            .once('end', () => {
+            req._isReady?.resolve();
+            Object.defineProperty(req, 'body', {
+                get: () => {
+                    if (!req._body) {
+                        let charset = contentType.match(/charset=(\S+)/)?.[1];
+                        if (charset !== 'utf8' && charset !== 'latin1' && charset !== 'ascii')
+                            charset = 'utf8';
+                        const bodyString = Buffer.concat(req.rawBody).toString(charset);
+                        if (contentType.startsWith('application/x-www-form-urlencoded')) {
+                            req._body = querystring.parse(bodyString);
+                        }
+                        else if (bodyString.startsWith('{') || bodyString.startsWith('[')) {
+                            try {
+                                req._body = JSON.parse(bodyString);
+                            }
+                            catch {
+                                return res.jsonError(405);
+                            }
+                        }
+                        else
+                            req._body = {};
+                    }
+                    return req._body;
+                },
+                configurable: true,
+                enumerable: true
+            });
+            return next();
+        });
+    }
+}
+export class UploadPlugin extends Plugin {
+    priority = -70;
+    name = 'upload';
+    _maxFileSize;
+    _uploadDir;
+    constructor(options) {
+        super();
+        this._maxFileSize = options?.maxFileSize || defaultMaxFileSize;
+        this._uploadDir = options?.uploadDir;
+    }
+    handler(req, res, next) {
+        if (!req.readable || req.method === 'GET')
+            return next();
+        const contentType = req.headers['content-type'] || '';
+        if (!contentType.startsWith('multipart/form-data'))
+            return next();
+        if (!req._isReady) {
+            req._isReady = deferPromise((err) => {
+                req._isReady = undefined;
+                if (err) {
+                    req.pause();
+                    if (!res.headersSent)
+                        res.setHeader('Connection', 'close');
+                    res.error('statusCode' in err ? err.statusCode : 400);
                 }
                 else
-                    done = true;
-            }
-            else {
-                item = item.last || item.tree[name] || item.param;
-                if (item && item.name) {
-                    req.params[item.name] = name;
-                    req.paramsList.push(name);
+                    res.removeHeader('Connection');
+            });
+        }
+        req.pause();
+        res.setHeader('Connection', 'close');
+        if (!this._uploadDir)
+            return res.error(405);
+        const uploadDir = path.resolve(this._uploadDir);
+        const files = [];
+        req.files = async () => {
+            if (req.isReady)
+                return files;
+            req.resume();
+            await req.waitReady();
+            return files;
+        };
+        const boundaryIdx = contentType.indexOf('boundary=');
+        if (boundaryIdx < 0)
+            return res.error(405);
+        const boundary = Buffer.from('--' + contentType.slice(boundaryIdx + 9).trim());
+        const lookahead = boundary.length + 6;
+        let lastFile;
+        let fileStream;
+        let buffer = Buffer.alloc(0);
+        const chunkParse = (chunk) => {
+            buffer = Buffer.concat([buffer, chunk]);
+            while (buffer.length > 0) {
+                if (!fileStream) {
+                    const boundaryIndex = buffer.indexOf(boundary);
+                    if (boundaryIndex < 0)
+                        break;
+                    const headerEndIndex = buffer.indexOf('\r\n\r\n', boundaryIndex);
+                    if (headerEndIndex < 0)
+                        break;
+                    const header = buffer.subarray(boundaryIndex, headerEndIndex).toString();
+                    const contentType = header.match(/content-type: ([^\r\n;]+)/i);
+                    const filenameMatch = header.match(/filename="(.+?)"/);
+                    if (filenameMatch) {
+                        let filePath;
+                        do {
+                            filePath = path.resolve(path.join(uploadDir, crypto.randomBytes(16).toString('hex') + '.tmp'));
+                        } while (fs.existsSync(filePath));
+                        buffer = buffer.slice(headerEndIndex + 4);
+                        lastFile = {
+                            name: filenameMatch[1],
+                            fileName: filenameMatch[1],
+                            contentType: contentType && contentType[1] || undefined,
+                            filePath,
+                            size: 0
+                        };
+                        fileStream = fs.createWriteStream(filePath);
+                        files.push(lastFile);
+                    }
+                    else {
+                        const nextBoundary = buffer.indexOf(boundary, boundaryIndex + boundary.length);
+                        if (nextBoundary === -1)
+                            break;
+                        buffer = buffer.subarray(nextBoundary);
+                    }
+                }
+                else {
+                    const nextBoundaryIndex = buffer.indexOf(boundary);
+                    const nextBoundaryIndexEnd = nextBoundaryIndex + boundary.length;
+                    if (nextBoundaryIndex > 1 && buffer[nextBoundaryIndex - 2] === 13 && buffer[nextBoundaryIndex - 1] === 10
+                        && ((buffer[nextBoundaryIndexEnd] === 13 && buffer[nextBoundaryIndexEnd + 1] === 10)
+                            || (buffer[nextBoundaryIndexEnd] === 45 && buffer[nextBoundaryIndexEnd + 1] === 45))) {
+                        fileStream.write(buffer.subarray(0, nextBoundaryIndex - 2));
+                        fileStream.end();
+                        lastFile.size += nextBoundaryIndex - 2;
+                        fileStream = undefined;
+                        if (buffer[nextBoundaryIndexEnd] === 45)
+                            req._isReady?.resolve();
+                        buffer = buffer.subarray(nextBoundaryIndex);
+                    }
+                    else {
+                        const safeWriteLength = buffer.length - lookahead;
+                        if (safeWriteLength > 0) {
+                            lastFile.size += safeWriteLength;
+                            fileStream.write(buffer.subarray(0, safeWriteLength));
+                            buffer = buffer.subarray(safeWriteLength);
+                        }
+                        break;
+                    }
                 }
             }
-        }
-        if (lastItem !== item)
-            item?.hook?.forEach((hook) => rstack.push(hook.bind(item)));
-        item?.next?.forEach((cb) => rstack.push(cb));
-        if (!rstack.length)
+        };
+        const _removeTempFiles = () => {
+            if (!req.isReady)
+                req._isReady?.resolve(new Error('Upload error'));
+            if (fileStream) {
+                fileStream.close();
+                fileStream = undefined;
+            }
+            files.forEach(f => {
+                if (f.filePath)
+                    fs.unlink(f.filePath, NOOP);
+                delete f.filePath;
+            });
+            files.splice(0);
+            req._isReady?.resolve();
+        };
+        next();
+        req.once('error', () => req._isReady?.resolve(new Error('Upload error')))
+            .on('data', chunk => chunkParse(chunk))
+            .once('end', () => req._isReady?.resolve(new Error('Upload error')));
+        res.once('finish', () => _removeTempFiles());
+        res.once('error', () => _removeTempFiles());
+        res.once('close', () => _removeTempFiles());
+    }
+}
+const EMPTY_BUFFER = Buffer.alloc(0);
+const DEFLATE_TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
+/** WebSocket class */
+export class WebSocket extends EventEmitter {
+    _socket;
+    _frame;
+    _buffers = [EMPTY_BUFFER];
+    _buffersLength = 0;
+    _options;
+    ready = false;
+    constructor(req, options) {
+        super();
+        this._socket = req.socket;
+        this._options = {
+            maxPayload: 1024 * 1024,
+            permessageDeflate: false,
+            maxWindowBits: 15,
+            timeout: 120000,
+            ...options
+        };
+        this._socket.setTimeout(this._options.timeout || 120000);
+        const key = req.headers['sec-websocket-key'];
+        const upgrade = req.headers.upgrade;
+        const version = +(req.headers['sec-websocket-version'] || 0);
+        const extensions = req.headers['sec-websocket-extensions'];
+        const headers = [];
+        if (!key || !upgrade || upgrade.toLocaleLowerCase() !== 'websocket' || version !== 13 || req.method !== 'GET') {
+            this._abort('Invalid WebSocket request', 400);
             return;
-        this._walkStack(rstack, req, res, next);
-        return true;
-    }
-    _add(method, url, key, middlewares) {
-        if (key === 'next')
-            this.server.emit('route', {
-                method,
-                url,
-                middlewares
-            });
-        middlewares = middlewares.map(m => this.bind(m));
-        let item = this._tree[method];
-        if (!item)
-            item = this._tree[method] = { tree: {} };
-        if (!url.startsWith('/')) {
-            if (method === '*' && url === '') {
-                this._stack.push(...middlewares);
-                return this;
-            }
-            url = '/' + url;
-        }
-        const reg = /\/(:?)([^/*]+)(\*?)/g;
-        let m;
-        while (m = reg.exec(url)) {
-            const param = m[1], name = m[2], last = m[3];
-            if (last) {
-                item.last = { name: name };
-                item = item.last;
-            }
-            else {
-                if (!item.tree)
-                    throw new Error('Invalid route path');
-                if (param) {
-                    item = item.param = item.param || { tree: {}, name: name };
-                }
-                else {
-                    let subitem = item.tree[name];
-                    if (!subitem)
-                        subitem = item.tree[name] = { tree: {} };
-                    item = subitem;
-                }
-            }
         }
-        if (!item[key])
-            item[key] = [];
-        item[key].push(...middlewares);
+        if (this._options.permessageDeflate && extensions?.includes('permessage-deflate')) {
+            let header = 'Sec-WebSocket-Extensions: permessage-deflate';
+            if ((this._options.maxWindowBits || 15) < 15 && extensions.includes('client_max_window_bits'))
+                header += `; client_max_window_bits=${this._options.maxWindowBits}`;
+            headers.push(header);
+            this._options.deflate = true;
+        }
+        this.ready = true;
+        this._upgrade(key, headers);
     }
-    /** Clear routes and middlewares */
-    clear() {
-        this._tree = {};
-        this._stack = [];
-        return this;
+    _upgrade(key, headers = []) {
+        const digest = crypto.createHash('sha1')
+            .update(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+            .digest('base64');
+        headers = [
+            'HTTP/1.1 101 Switching Protocols',
+            'Upgrade: websocket',
+            'Connection: Upgrade',
+            `Sec-WebSocket-Accept: ${digest}`,
+            ...headers,
+            '',
+            ''
+        ];
+        this._socket.write(headers.join('\r\n'));
+        this._socket.on('error', this._errorHandler.bind(this));
+        this._socket.on('data', this._dataHandler.bind(this));
+        this._socket.on('close', () => this.emit('close'));
+        this._socket.on('end', () => this.emit('end'));
     }
-    /**
-     * Add middleware route.
-     * Middlewares may return promises for res.jsonSuccess(...), throw errors for res.error(...), return string or {} for res.send(...)
-     *
-     * @signature add(plugin: Plugin)
-     * @param {Plugin} plugin plugin module instance
-     * @return {Promise<>}
-     *
-     * @signature add(pluginid: string, ...args: any)
-     * @param {string} pluginid pluginid module
-     * @param {...any} args arguments passed to constructor
-     * @return {Promise<>}
-     *
-     * @signature add(pluginClass: typeof Plugin, ...args: any)
-     * @param {typeof Plugin} pluginClass plugin class
-     * @param {...any} args arguments passed to constructor
-     * @return {Promise<>}
-     *
-     * @signature add(middleware: Middleware)
-     * @param {Middleware} middleware
-     * @return {Promise<>}
-     *
-     * @signature add(methodUrl: string, ...middlewares: any)
-     * @param {string} methodUrl 'METHOD /url' or '/url'
-     * @param {...any} middlewares
-     * @return {Promise<>}
-     *
-     * @signature add(methodUrl: string, controllerClass: typeof Controller)
-     * @param {string} methodUrl 'METHOD /url' or '/url'
-     * @param {typeof Controller} controllerClass
-     * @return {Promise<>}
-     *
-     * @signature add(methodUrl: string, routes: Array<Array<any>>)
-     * @param {string} methodUrl 'METHOD /url' or '/url'
-     * @param {Array<Array<any>>} routes list with subroutes: ['METHOD /suburl', ...middlewares]
-     * @return {Promise<>}
-     *
-     * @signature add(methodUrl: string, routes: Array<Array<any>>)
-     * @param {string} methodUrl 'METHOD /url' or '/url'
-     * @param {Array<Array<any>>} routes list with subroutes: ['METHOD /suburl', ...middlewares]
-     * @return {Promise<>}
-     *
-     * @signature add(routes: { [key: string]: Array<any> })
-     * @param { {[key: string]: Array<any>} } routes list with subroutes: 'METHOD /suburl': [...middlewares]
-     * @return {Promise<>}
-     *
-     * @signature add(methodUrl: string, routes: { [key: string]: Array<any> })
-     * @param {string} methodUrl 'METHOD /url' or '/url'
-     * @param { {[key: string]: Array<any>} } routes list with subroutes: 'METHOD /suburl': [...middlewares]
-     * @return {Promise<>}
-     */
-    async use(...args) {
-        if (!args[0])
-            return;
-        this.server._waiter.startJob();
-        for (let i = 0; i < args.length; i++)
-            args[i] = await args[i];
-        // use(plugin)
-        if (args[0] instanceof Plugin) {
-            await this._plugin(args[0]);
-            return this.server._waiter.endJob();
+    /** Close connection */
+    close(reason, data) {
+        if (reason !== undefined) {
+            const buffer = Buffer.alloc(2 + (data ? data.length : 0));
+            buffer.writeUInt16BE(reason, 0);
+            if (data)
+                data.copy(buffer, 2);
+            data = buffer;
         }
-        // use(pluginid, ...args)
-        if (typeof args[0] === 'string' && MicroServer.plugins[args[0]]) {
-            const constructor = MicroServer.plugins[args[0]];
-            const plugin = new constructor(this, ...args.slice(1));
-            await this._plugin(plugin);
-            return this.server._waiter.endJob();
+        return this._sendFrame(0x88, data || EMPTY_BUFFER, () => this._socket.destroy());
+    }
+    /** Generate WebSocket frame from data */
+    static getFrame(data, options) {
+        let msgType = 8;
+        let dataLength = 0;
+        if (typeof data === 'string') {
+            msgType = 1;
+            dataLength = Buffer.byteLength(data, 'utf8');
         }
-        // use(PluginClass, ...args)
-        if (typeof args[0] === 'function' && args[0].prototype instanceof Plugin) {
-            const plugin = new args[0](this, ...args.slice(1));
-            await this._plugin(plugin);
-            return this.server._waiter.endJob();
+        else if (data instanceof Buffer) {
+            msgType = 2;
+            dataLength = data.length;
         }
-        // use(middleware)
-        if (isFunction(args[0])) {
-            this._middleware(args[0]);
-            return this.server._waiter.endJob();
+        else if (typeof data === 'number') {
+            msgType = data;
         }
-        let method = '*', url = '/';
-        if (typeof args[0] === 'string') {
-            const m = args[0].match(/^([A-Z]+) (.*)/);
-            if (m)
-                [method, url] = [m[1], m[2]];
+        const headerSize = 2 + (dataLength < 126 ? 0 : dataLength < 65536 ? 2 : 8) + (dataLength && options?.mask ? 4 : 0);
+        const frame = Buffer.allocUnsafe(headerSize + dataLength);
+        frame[0] = 0x80 | msgType;
+        frame[1] = dataLength > 65535 ? 127 : dataLength > 125 ? 126 : dataLength;
+        if (dataLength > 65535)
+            frame.writeBigUInt64BE(dataLength, 2);
+        else if (dataLength > 125)
+            frame.writeUInt16BE(dataLength, 2);
+        if (dataLength && frame.length > dataLength) {
+            if (typeof data === 'string')
+                frame.write(data, headerSize, 'utf8');
             else
-                url = args[0];
-            if (!url.startsWith('/'))
-                throw new Error(`Invalid url ${url}`);
-            args = args.slice(1);
-        }
-        // use('/url', ControllerClass)
-        if (typeof args[0] === 'function' && args[0].prototype instanceof Controller) {
-            const routes = await args[0].routes();
-            if (routes)
-                args[0] = routes;
-        }
-        // use('/url', [ ['METHOD /url', ...], {'METHOD } ])
-        if (Array.isArray(args[0])) {
-            if (method !== '*')
-                throw new Error('Invalid router usage');
-            for (const item of args[0]) {
-                if (Array.isArray(item)) {
-                    // [methodUrl, ...middlewares]
-                    if (typeof item[0] !== 'string' || !item[0].match(/^(\w+ )?\//))
-                        throw new Error('Url expected');
-                    await this.use(item[0].replace(/\//, (url === '/' ? '' : url) + '/'), ...item.slice(1));
-                }
-                else
-                    throw new Error('Invalid param');
-            }
-            return this.server._waiter.endJob();
+                data.copy(frame, headerSize);
         }
-        // use('/url', {'METHOD /url': [...middlewares], ... } ])
-        if (typeof args[0] === 'object' && args[0].constructor === Object) {
-            if (method !== '*')
-                throw new Error('Invalid router usage');
-            for (const [subUrl, subArgs] of Object.entries(args[0])) {
-                if (!subUrl.match(/^(\w+ )?\//))
-                    throw new Error('Url expected');
-                await this.use(subUrl.replace(/\//, (url === '/' ? '' : url) + '/'), ...(Array.isArray(subArgs) ? subArgs : [subArgs]));
+        if (dataLength && options?.mask) {
+            let i = headerSize, h = headerSize - 4;
+            for (let i = 0; i < 4; i++)
+                frame[h + i] = Math.floor(Math.random() * 256);
+            for (let j = 0; j < dataLength; j++, i++) {
+                frame[i] ^= frame[h + (j & 3)];
             }
-            return this.server._waiter.endJob();
-        }
-        // use('/url', ...middleware)
-        this._add(method, url, 'next', args.filter((o) => o));
-        return this.server._waiter.endJob();
-    }
-    _middleware(middleware) {
-        if (!middleware)
-            return;
-        const priority = (middleware?.priority || 0) - 1;
-        const stack = priority < -1 ? this._stackAfter : this._stack;
-        const idx = stack.findIndex(f => 'priority' in f
-            && priority >= (f.priority || 0));
-        stack.splice(idx < 0 ? stack.length : idx, 0, middleware);
-    }
-    async _plugin(plugin) {
-        let added;
-        if (plugin.name) {
-            if (this.plugins[plugin.name])
-                throw new Error(`Plugin ${plugin.name} already added`);
-            this.plugins[plugin.name] = plugin;
-            added = plugin.name;
-        }
-        await plugin.initialise?.();
-        if (plugin.handler) {
-            const middleware = plugin.handler.bind(plugin);
-            middleware.plugin = plugin;
-            middleware.priority = plugin.priority;
-            this._middleware(middleware);
-        }
-        if (plugin.routes)
-            await this.use(isFunction(plugin.routes) ? await plugin.routes() : plugin.routes);
-        if (added)
-            this.emit(added);
-    }
-    async waitPlugin(id) {
-        if (!this.plugins[id])
-            await this._waiter.wait(id);
-        return this.plugins[id];
-    }
-    /** Add hook */
-    hook(url, ...mid) {
-        const m = url.match(/^([A-Z]+) (.*)/);
-        if (m) {
-            const [method, url] = [m[1], m[2]];
-            this._add(method, url, 'hook', mid);
-        }
-        else {
-            for (const method of ['*', 'GET', 'POST', 'PUT', 'DELETE', 'PATCH'])
-                this._add(method, url, 'hook', mid);
         }
+        return frame;
     }
-    /** Check if middleware allready added */
-    has(mid) {
-        return this._stack.includes(mid) || (mid.name && !!this._stack.find(f => f.name === mid.name)) || false;
-    }
-}
-export class MicroServer extends EventEmitter {
-    constructor(config) {
-        super();
-        this._waiter = new Waiter();
-        this._methods = {};
-        let promise = Promise.resolve();
-        this.config = {
-            maxBodySize: defaultMaxBodySize,
-            methods: defaultMethods,
-            ...config,
-            root: path.normalize(config.root || process.cwd())
-        };
-        (config.methods || defaultMethods).split(',').map(s => s.trim()).forEach(m => this._methods[m] = true);
-        this.router = new Router(this);
-        this.servers = new Set();
-        this.sockets = new Set();
-        if (config.routes)
-            this.use(config.routes);
-        for (const key in MicroServer.plugins) {
-            if (config[key])
-                this.router.use(MicroServer.plugins[key], config[key]);
-        }
-        if (config.listen) {
-            this._waiter.startJob();
-            this.listen({
-                tls: config.tls,
-                listen: config.listen || 8080
-            }).then(() => {
-                this._waiter.endJob();
+    /** Send data */
+    send(data) {
+        let msgType = typeof data === 'string' ? 1 : 2;
+        if (typeof data === 'string')
+            data = Buffer.from(data, 'utf8');
+        if (this._options.deflate && data.length > 256) {
+            const output = [];
+            const deflate = zlib.createDeflateRaw({
+                windowBits: this._options.maxWindowBits
+            });
+            deflate.write(data);
+            deflate.on('data', (chunk) => output.push(chunk));
+            deflate.flush(() => {
+                if (output.length > 0 && output[output.length - 1].length > 4)
+                    output[output.length - 1] = output[output.length - 1].subarray(0, output[output.length - 1].length - 4);
+                this._sendFrame(0xC0 | msgType, Buffer.concat(output));
             });
         }
-        this._waiter.wait().then(() => this.emit('ready'));
-    }
-    /** Add one time listener or call immediatelly for 'ready' */
-    once(name, cb) {
-        if (name === 'ready' && this.isReady)
-            cb();
         else
-            super.once(name, cb);
-        return this;
-    }
-    /** Add listener and call immediatelly for 'ready'  */
-    on(name, cb) {
-        if (name === 'ready' && this.isReady)
-            cb();
-        super.on(name, cb);
-        return this;
-    }
-    get isReady() {
-        return !this._waiter.isBusy();
+            return this._sendFrame(0x80 | msgType, data);
     }
-    async waitReady() {
-        if (this.isReady)
-            return;
-        return this._waiter.wait();
+    _errorHandler(error) {
+        this.emit('error', error);
+        if (this.ready)
+            this.close(error instanceof WebSocketError && error.statusCode || 1002);
+        else
+            this._socket.destroy();
+        this.ready = false;
     }
-    async waitPlugin(id) {
-        await this.router.waitPlugin(id);
+    _headerLength(buffer) {
+        if (this._frame)
+            return 0;
+        if (!buffer || buffer.length < 2)
+            return 2;
+        let hederInfo = buffer[1];
+        return 2 + (hederInfo & 0x80 ? 4 : 0) + ((hederInfo & 0x7F) === 126 ? 2 : 0) + ((hederInfo & 0x7F) === 127 ? 8 : 0);
     }
-    /** Listen server, should be used only if config.listen is not set */
-    listen(config) {
-        const listen = (config?.listen || this.config.listen || 0) + '';
-        const handler = config?.handler || this.handler.bind(this);
-        const tlsConfig = config ? config.tls : this.config.tls;
-        const readFile = (data) => data && (data.indexOf('\n') > 0 ? data : fs.readFileSync(data));
-        function tlsOptions() {
-            return {
-                cert: readFile(tlsConfig?.cert),
-                key: readFile(tlsConfig?.key),
-                ca: readFile(tlsConfig?.ca)
-            };
-        }
-        function tlsOptionsReload(srv) {
-            if (tlsConfig?.cert && tlsConfig.cert.indexOf('\n') < 0) {
-                let debounce;
-                fs.watch(tlsConfig.cert, () => {
-                    clearTimeout(debounce);
-                    debounce = setTimeout(() => {
-                        debounce = undefined;
-                        srv.setSecureContext(tlsOptions());
-                    }, 2000);
-                });
+    _dataHandler(data) {
+        while (data.length) {
+            let frame = this._frame;
+            if (!frame) {
+                let lastBuffer = this._buffers[this._buffers.length - 1];
+                this._buffers[this._buffers.length - 1] = lastBuffer = Buffer.concat([lastBuffer, data]);
+                let headerLength = this._headerLength(lastBuffer);
+                if (lastBuffer.length < headerLength)
+                    return;
+                const headerBits = lastBuffer[0];
+                const lengthBits = lastBuffer[1] & 0x7F;
+                this._buffers.pop();
+                data = lastBuffer.subarray(headerLength);
+                // parse header
+                frame = this._frame = {
+                    fin: (headerBits & 0x80) !== 0,
+                    rsv1: (headerBits & 0x40) !== 0,
+                    opcode: headerBits & 0x0F,
+                    mask: (lastBuffer[1] & 0x80) ? lastBuffer.subarray(headerLength - 4, headerLength) : EMPTY_BUFFER,
+                    length: lengthBits === 126 ? lastBuffer.readUInt16BE(2) : lengthBits === 127 ? lastBuffer.readBigUInt64BE(2) : lengthBits,
+                    lengthReceived: 0,
+                    index: this._buffers.length
+                };
+            }
+            let toRead = frame.length - frame.lengthReceived;
+            if (toRead > data.length)
+                toRead = data.length;
+            if (this._options.maxPayload && this._options.maxPayload < this._buffersLength + frame.length) {
+                this._errorHandler(new WebSocketError('Payload too big', 1009));
+                return;
             }
-        }
-        const reg = /^((?<proto>\w+):\/\/)?(?<host>(\[[^\]]+\]|[a-z][^:,]+|\d+\.\d+\.\d+\.\d+))?:?(?<port>\d+)?/;
-        listen.split(',').forEach(listen => {
-            this._waiter.startJob('listen');
-            let { proto, host, port } = reg.exec(listen)?.groups || {};
-            let srv;
-            switch (proto) {
-                case 'tcp':
-                    if (!config?.handler)
-                        throw new Error('Handler is required for tcp');
-                    srv = net.createServer(handler);
-                    break;
-                case 'tls':
-                    if (!config?.handler)
-                        throw new Error('Handler is required for tls');
-                    srv = tls.createServer(tlsOptions(), handler);
-                    tlsOptionsReload(srv);
-                    break;
-                case 'https':
-                    port = port || '443';
-                    srv = https.createServer(tlsOptions(), handler);
-                    tlsOptionsReload(srv);
-                    break;
-                default:
-                    port = port || '80';
-                    srv = http.createServer(handler);
-                    break;
+            // unmask
+            for (let i = 0, j = frame.lengthReceived; i < toRead; i++, j++)
+                data[i] ^= frame.mask[j & 3];
+            frame.lengthReceived += toRead;
+            if (frame.lengthReceived < frame.length) {
+                this._buffers.push(data);
+                return;
             }
-            this.servers.add(srv);
-            if (port === '0') // skip listening
-                this._waiter.endJob('listen');
-            else {
-                srv.listen(parseInt(port), host?.replace(/[\[\]]/g, '') || '0.0.0.0', () => {
-                    const addr = srv.address();
-                    this.emit('listen', addr.port, addr.address, srv);
-                    srv._ready = true;
-                    this._waiter.endJob('listen');
-                });
+            this._buffers.push(data.subarray(0, toRead));
+            this._buffersLength += toRead;
+            data = data.subarray(toRead);
+            if (frame.opcode >= 8) {
+                const message = Buffer.concat(this._buffers.splice(frame.index));
+                switch (frame.opcode) {
+                    case 8:
+                        if (!frame.length)
+                            this.emit('close');
+                        else {
+                            const code = message.readInt16BE(0);
+                            if (frame.length === 2)
+                                this.emit('close', code);
+                            else
+                                this.emit('close', code, message.subarray(2));
+                        }
+                        this._socket.destroy();
+                        return;
+                    case 9:
+                        if (message.length)
+                            this.emit('ping', message);
+                        else
+                            this.emit('ping');
+                        if (this._options.autoPong)
+                            this.pong(message);
+                        break;
+                    case 10:
+                        if (message.length)
+                            this.emit('pong', message);
+                        else
+                            this.emit('pong');
+                        break;
+                    default:
+                        return this._errorHandler(new WebSocketError('Invalid WebSocket frame'));
+                }
             }
-            srv.on('error', err => {
-                srv.close();
-                this.servers.delete(srv);
-                if (!srv._ready)
-                    this._waiter.endJob('listen');
-                this.emit('error', err);
-            });
-            srv.on('connection', s => {
-                this.sockets.add(s);
-                s.once('close', () => this.sockets.delete(s));
-            });
-            srv.on('upgrade', this.handlerUpgrade.bind(this));
-        });
-        return this._waiter.wait('listen');
+            else if (frame.fin) {
+                if (!frame.opcode)
+                    return this._errorHandler(new WebSocketError('Invalid WebSocket frame'));
+                if (this._options.deflate && frame.rsv1) {
+                    const output = [];
+                    const inflate = zlib.createInflateRaw({
+                        windowBits: this._options.maxWindowBits
+                    });
+                    inflate.on('data', (chunk) => output.push(chunk));
+                    inflate.on('error', (err) => this._errorHandler(err));
+                    for (const buffer of this._buffers)
+                        inflate.write(buffer);
+                    inflate.write(DEFLATE_TRAILER);
+                    inflate.flush(() => {
+                        if (this.ready) {
+                            const message = Buffer.concat(output);
+                            this.emit('message', frame.opcode === 1 ? message.toString('utf8') : message);
+                        }
+                    });
+                }
+                else {
+                    const message = Buffer.concat(this._buffers);
+                    this.emit('message', frame.opcode === 1 ? message.toString('utf8') : message);
+                }
+                this._buffers = [];
+                this._buffersLength = 0;
+            }
+            this._frame = undefined;
+            this._buffers.push(EMPTY_BUFFER);
+        }
     }
-    /** Add middleware, routes, etc.. see {router.use} */
-    use(...args) {
-        return this.router.use(...args);
+    _abort(message, code, headers) {
+        code = code || 400;
+        message = message || http.STATUS_CODES[code] || 'Closed';
+        headers = [
+            `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}`,
+            'Connection: close',
+            'Content-Type: ' + message.startsWith('<') ? 'text/html' : 'text/plain',
+            `Content-Length: ${Buffer.byteLength(message)}`,
+            '',
+            message
+        ];
+        this._socket.once('finish', () => {
+            this._socket.destroy();
+            this.emit('close');
+        });
+        this._socket.end(headers.join('\r\n'));
+        this.emit('error', new Error(message));
     }
-    /** Default server handler */
-    handler(req, res) {
-        this.requestInit(req, res);
-        // limit input data size
-        if (parseInt(req.headers['content-length'] || '-1') > (this.config.maxBodySize || defaultMaxBodySize)) {
-            req.pause();
-            res.error(413);
-            return;
-        }
-        this.handlerInit(req, res, () => this.handlerLast(req, res));
+    /** Send ping frame */
+    ping(buffer) {
+        this._sendFrame(0x89, buffer || EMPTY_BUFFER);
     }
-    requestInit(req, res) {
-        Object.setPrototypeOf(req, ServerRequest.prototype);
-        req._init(this.router);
-        if (res) {
-            Object.setPrototypeOf(res, ServerResponse.prototype);
-            res._init(this.router);
-        }
+    /** Send pong frame */
+    pong(buffer) {
+        this._sendFrame(0x8A, buffer || EMPTY_BUFFER);
     }
-    /** Preprocess request, used by {MicroServer.handler} */
-    handlerInit(req, res, next) {
-        let cors = this.config.cors;
-        if (cors && req.headers.origin) {
-            if (cors === true)
-                cors = '*';
-            if (typeof cors === 'string')
-                cors = { origin: cors, headers: 'Content-Type', credentials: true };
-            if (cors.origin)
-                res.setHeader('Access-Control-Allow-Origin', cors.origin);
-            if (cors.headers)
-                res.setHeader('Access-Control-Allow-Headers', cors.headers);
-            if (cors.credentials)
-                res.setHeader('Access-Control-Allow-Credentials', 'true');
-            if (cors.expose)
-                res.setHeader('Access-Control-Expose-Headers', cors.expose);
-            if (cors.maxAge)
-                res.setHeader('Access-Control-Max-Age', cors.maxAge);
-        }
-        if (req.method === 'OPTIONS') {
-            res.statusCode = 204;
-            res.setHeader('Allow', this.config.methods || defaultMethods);
-            res.end();
-            return;
-        }
-        if (!req.method || !this._methods[req.method]) {
-            res.statusCode = 405;
-            res.setHeader('Allow', this.config.methods || defaultMethods);
-            res.end();
+    _sendFrame(opcode, data, cb) {
+        if (!this.ready)
             return;
+        const dataLength = data.length;
+        const headerSize = 2 + (dataLength < 126 ? 0 : dataLength < 65536 ? 2 : 8);
+        const frame = Buffer.allocUnsafe(headerSize + (dataLength < 4096 ? dataLength : 0));
+        frame[0] = opcode;
+        frame[1] = dataLength > 65535 ? 127 : dataLength > 125 ? 126 : dataLength;
+        if (dataLength > 65535)
+            frame.writeBigUInt64BE(dataLength, 2);
+        else if (dataLength > 125)
+            frame.writeUInt16BE(dataLength, 2);
+        if (dataLength && frame.length > dataLength) {
+            data.copy(frame, headerSize);
+            this._socket.write(frame, cb);
         }
-        if (req.method === 'HEAD') {
-            req.method = 'GET';
-            res.headersOnly = true;
-        }
-        return req.bodyDecode(res, this.config, () => {
-            if ((req.rawBodySize && req.rawBody[0] && (req.rawBody[0][0] === 91 || req.rawBody[0][0] === 123))
-                || req.headers.accept?.includes?.('json') || req.headers['content-type']?.includes?.('json'))
-                res.isJson = true;
-            return req.router.handler(req, res, next);
-        });
-    }
-    /** Last request handler */
-    handlerLast(req, res, next) {
-        if (res.headersSent)
-            return;
-        if (!next)
-            next = () => res.error(404);
-        return next();
+        else
+            this._socket.write(frame, () => this._socket.write(data, cb));
     }
-    /** Default upgrade handler, used for WebSockets */
-    handlerUpgrade(req, socket, head) {
-        this.requestInit(req);
-        //req.headers = head
-        //(req as any)['head'] = head
+    on(event, listener) { return super.on(event, listener); }
+    addListener(event, listener) { return super.addListener(event, listener); }
+    once(event, listener) { return super.once(event, listener); }
+    off(event, listener) { return super.off(event, listener); }
+    removeListener(event, listener) { return super.removeListener(event, listener); }
+}
+export class WebSocketPlugin extends Plugin {
+    name = 'websocket';
+    _handler;
+    constructor(options, server) {
+        super();
+        if (!server)
+            throw new Error('Server instance is required');
+        this._handler = this.upgradeHandler.bind(this, server);
+        server.servers?.forEach(srv => this.addUpgradeHandler(srv));
+        server.on('listen', (port, address, srv) => this.addUpgradeHandler(srv));
+    }
+    addUpgradeHandler(srv) {
+        if (!srv.listeners('upgrade').includes(this._handler))
+            srv.on('upgrade', this._handler);
+    }
+    upgradeHandler(server, req, socket, head) {
+        ServerRequest.extend(req, server);
         const host = req.headers.host || '';
-        const router = this.vhosts?.[host] || this.router;
+        const vhostPlugin = server.getPlugin('vhost');
+        const vserver = vhostPlugin?.vhosts?.[host] || server;
+        req.method = 'WEBSOCKET';
         const res = {
+            req,
             get headersSent() {
                 return socket.bytesWritten > 0;
             },
@@ -1608,181 +1521,180 @@ export class MicroServer extends EventEmitter {
             socket,
             server,
             write(data) {
-                if (res.headersSent)
-                    throw new Error('Headers already sent');
-                let code = res.statusCode || 403;
-                if (code < 400) {
-                    data = 'Invalid WebSocket response';
-                    console.error(data);
-                    code = 500;
-                }
-                if (!data)
-                    data = http.STATUS_CODES[code] || '';
-                const headers = [
-                    `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}`,
-                    'Connection: close',
-                    'Content-Type: text/html',
-                    `Content-Length: ${Buffer.byteLength(data)}`,
-                    '',
-                    data
-                ];
-                socket.write(headers.join('\r\n'), () => { socket.destroy(); });
-            },
-            error(code) {
-                res.statusCode = code || 403;
-                res.write();
-            },
-            end(data) {
-                res.write(data);
-            },
-            send(data) {
-                res.write(data);
-            },
-            setHeader() { }
-        };
-        router.handler(req, res, () => res.error(404), 'WEBSOCKET');
-    }
-    /** Close server instance */
-    async close() {
-        return new Promise((resolve) => {
-            let count = 0;
-            function done() {
-                count--;
-                if (!count)
-                    setTimeout(() => resolve(), 2);
-            }
-            for (const s of this.servers) {
-                count++;
-                s.once('close', done);
-                s.close();
-            }
-            this.servers.clear();
-            for (const s of this.sockets) {
-                count++;
-                s.once('close', done);
-                s.destroy();
-            }
-            this.sockets.clear();
-        }).then(() => {
-            this.emit('close');
-        });
-    }
-    /** Add route, alias to `server.router.use(url, ...args)` */
-    all(url, ...args) {
-        this.router.use(url, ...args);
-        return this;
-    }
-    /** Add route, alias to `server.router.use('GET ' + url, ...args)` */
-    get(url, ...args) {
-        this.router.use('GET ' + url, ...args);
-        return this;
-    }
-    /** Add route, alias to `server.router.use('POST ' + url, ...args)` */
-    post(url, ...args) {
-        this.router.use('POST ' + url, ...args);
-        return this;
-    }
-    /** Add route, alias to `server.router.use('PUT ' + url, ...args)` */
-    put(url, ...args) {
-        this.router.use('PUT ' + url, ...args);
-        return this;
-    }
-    /** Add route, alias to `server.router.use('PATCH ' + url, ...args)` */
-    patch(url, ...args) {
-        this.router.use('PATCH ' + url, ...args);
-        return this;
-    }
-    /** Add route, alias to `server.router.use('DELETE ' + url, ...args)` */
-    delete(url, ...args) {
-        this.router.use('DELETE ' + url, ...args);
-        return this;
-    }
-    /** Add websocket handler, alias to `server.router.use('WEBSOCKET ' + url, ...args)` */
-    websocket(url, ...args) {
-        this.router.use('WEBSOCKET ' + url, ...args);
-        return this;
+                if (res.headersSent)
+                    throw new Error('Headers already sent');
+                let code = res.statusCode || 403;
+                if (code < 400) {
+                    data = 'Invalid WebSocket response';
+                    server.emit('error', new Error(data));
+                    code = 500;
+                }
+                if (!data)
+                    data = http.STATUS_CODES[code] || '';
+                const headers = [
+                    `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}`,
+                    'Connection: close',
+                    'Content-Type: text/html',
+                    `Content-Length: ${Buffer.byteLength(data)}`,
+                    '',
+                    data
+                ];
+                socket.write(headers.join('\r\n'), () => { socket.destroy(); });
+            },
+            error(code) {
+                res.statusCode = code || 403;
+                res.write();
+            },
+            end(data) {
+                res.write(data);
+            },
+            send(data) {
+                res.write(data);
+            },
+            getHeader() { },
+            setHeader() { }
+        };
+        vserver.handler(req, res);
+        //vserver.handlerRouter(req, res as unknown as ServerResponse, () => res.error(404))
     }
-    /** Add router hook, alias to `server.router.hook(url, ...args)` */
-    hook(url, ...args) {
-        this.router.hook(url, ...args.filter((o) => o));
-        return this;
+    static create(req, options) {
+        return new WebSocket(req, options);
     }
 }
-MicroServer.plugins = {};
+// #endregion WebSocket
+// #region TrustProxyPlugin
 /** Trust proxy plugin, adds `req.ip` and `req.localip` */
-class TrustProxyPlugin extends Plugin {
-    constructor(router, options) {
-        super(router);
-        this.priority = 110;
-        this.name = 'trustProxy';
-        this.trustProxy = [];
-        this.trustProxy = options || [];
+export class TrustProxyPlugin extends Plugin {
+    priority = -60;
+    name = 'trustproxy';
+    _trustProxy = [];
+    constructor(options) {
+        super();
+        this._trustProxy = options || [];
     }
     isLocal(ip) {
         return !!ip.match(/^(127\.|10\.|192\.168\.|172\.16\.|fe80|fc|fd|::)/);
     }
     handler(req, res, next) {
-        req.ip = req.socket.remoteAddress || '::1';
         req.localip = this.isLocal(req.ip);
         const xip = req.headers['x-real-ip'] || req.headers['x-forwarded-for'];
         if (xip) {
-            if (!this.trustProxy.includes(req.ip))
+            if (!this._trustProxy.includes(req.ip))
                 return res.error(400);
-            if (req.headers['x-forwarded-proto'] === 'https') {
-                req.protocol = 'https';
+            if (req.headers['x-forwarded-proto'] === 'https')
                 req.secure = true;
-            }
             req.ip = Array.isArray(xip) ? xip[0] : xip;
             req.localip = this.isLocal(req.ip);
         }
         return next();
     }
 }
-MicroServer.plugins.trustProxy = TrustProxyPlugin;
+// #endregion TrustProxyPlugin
+// #region VHostPlugin
 /** Virtual host plugin */
-class VHostPlugin extends Plugin {
-    constructor(router, options) {
-        super(router);
-        this.priority = 100;
-        const server = router.server;
-        if (!server.vhosts) {
-            server.vhosts = {};
+export class VHostPlugin extends Plugin {
+    priority = -10;
+    vhosts;
+    constructor(options, server) {
+        super();
+        if (!server)
+            throw new Error('Server instance is required');
+        const vhostPlugin = server.getPlugin('vhost');
+        let vhosts = vhostPlugin?.vhosts;
+        if (!vhosts) {
+            vhosts = this.vhosts = {};
             this.name = 'vhost';
         }
-        else
+        else {
             this.handler = undefined;
+        }
         for (const host in options) {
-            if (!server.vhosts[host])
-                server.vhosts[host] = new Router(server);
-            server.vhosts[host].use(options[host]);
+            const v = options[host];
+            if (v instanceof MicroServer) {
+                vhosts[host] = v;
+                continue;
+            }
+            if (!vhosts[host])
+                vhosts[host] = new MicroServer({});
+            vhosts[host].use(options[host]);
         }
+        if (this.vhosts)
+            server.on('close', () => {
+                for (const host in this.vhosts)
+                    this.vhosts[host].emit('close');
+            });
     }
     handler(req, res, next) {
         const host = req.headers.host || '';
-        const router = req.router.server.vhosts?.[host];
-        if (router) {
-            req.router = res.router = router;
-            router.handler(req, res, () => req.router.server.handlerLast(req, res));
+        const server = this.vhosts?.[host];
+        if (server) {
+            req.server = server;
+            server.handler(req, res);
         }
         else
             next();
     }
 }
-MicroServer.plugins.vhost = VHostPlugin;
 const etagPrefix = crypto.randomBytes(4).toString('hex');
+//TODO: add precompressed .gz support
+//TODO: add unknown file extension handler
 /**
  * Static files middleware plugin
  * Usage: server.use('static', '/public')
  * Usage: server.use('static', { root: 'public', path: '/static' })
  */
-class StaticPlugin extends Plugin {
-    constructor(router, options) {
-        super(router);
+export class StaticFilesPlugin extends Plugin {
+    priority = 110;
+    /** Default mime types */
+    static mimeTypes = {
+        '.ico': 'image/x-icon',
+        '.htm': 'text/html',
+        '.html': 'text/html',
+        '.txt': 'text/plain',
+        '.js': 'text/javascript',
+        '.json': 'application/json',
+        '.css': 'text/css',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.svg': 'image/svg+xml',
+        '.mp3': 'audio/mpeg',
+        '.ogg': 'audio/ogg',
+        '.mp4': 'video/mp4',
+        '.pdf': 'application/pdf',
+        '.woff': 'application/x-font-woff',
+        '.woff2': 'application/x-font-woff2',
+        '.ttf': 'application/x-font-ttf',
+        '.gz': 'application/gzip',
+        '.zip': 'application/zip',
+        '.tgz': 'application/gzip',
+    };
+    /** Custom mime types */
+    mimeTypes;
+    /** File extension handlers */
+    handlers;
+    /** Files root directory */
+    root;
+    /** Ignore prefixes */
+    ignore;
+    /** Index file. default: 'index.html' */
+    index;
+    /** Update Last-Modified header. default: true */
+    lastModified;
+    /** Update ETag header. default: true */
+    etag;
+    /** Max file age in seconds (default: 31536000) */
+    maxAge;
+    prefix;
+    constructor(options, server) {
+        super();
         if (!options)
             options = {};
         if (typeof options === 'string')
-            options = { path: options };
-        this.mimeTypes = options.mimeTypes ? { ...StaticPlugin.mimeTypes, ...options.mimeTypes } : Object.freeze(StaticPlugin.mimeTypes);
+            options = { root: options };
+        // allow multiple instances
+        if (server && !server.getPlugin('static'))
+            this.name = 'static';
+        this.mimeTypes = options.mimeTypes ? { ...StaticFilesPlugin.mimeTypes, ...options.mimeTypes } : Object.freeze(StaticFilesPlugin.mimeTypes);
         this.root = path.resolve((options.root || options?.path || 'public').replace(/^\//, '')) + path.sep;
         this.ignore = (options.ignore || []).map((p) => path.normalize(path.join(this.root, p)) + path.sep);
         this.index = options.index || 'index.html';
@@ -1790,13 +1702,26 @@ class StaticPlugin extends Plugin {
         this.lastModified = options.lastModified !== false;
         this.etag = options.etag !== false;
         this.maxAge = options.maxAge;
-        router.use('GET /' + (options.path?.replace(/^[.\/]*/, '') || '').replace(/\/$/, '') + '/:path*', this.staticHandler.bind(this));
+        this.prefix = ('/' + (options.path?.replace(/^[.\/]*/, '') || '').replace(/\/$/, '')).replace(/\/$/, '');
     }
     /** Default static files handler */
-    staticHandler(req, res, next) {
+    handler(req, res, next) {
+        res.file = (path) => {
+            this.serveFile(req, res, typeof path === 'object' ? path : {
+                path,
+                mimeType: StaticFilesPlugin.mimeTypes[extname(path)] || 'application/octet-stream'
+            });
+        };
         if (req.method !== 'GET')
             return next();
-        let filename = path.normalize(path.join(this.root, (req.params && req.params.path) || req.pathname));
+        if (!('path' in req.params)) { // global handler
+            if (req.path.startsWith(this.prefix) && (req.path === this.prefix || req.path[this.prefix.length] === '/')) {
+                req.params.path = req.path.slice(this.prefix.length + 1);
+            }
+            else
+                return next();
+        }
+        let filename = path.normalize(path.join(this.root, req.params.path));
         if (!filename.startsWith(this.root)) // check root access
             return next();
         const firstch = basename(filename)[0];
@@ -1821,15 +1746,15 @@ class StaticPlugin extends Plugin {
                 req.filename = filename;
                 return handler.call(this, req, res, next);
             }
-            StaticPlugin.serveFile(req, res, {
+            this.serveFile(req, res, {
                 path: filename,
                 mimeType,
                 stats
             });
         });
     }
-    static serveFile(req, res, options) {
-        const filePath = options.root ? path.join(options.root, options.path) : options.path;
+    serveFile(req, res, options) {
+        const filePath = path.isAbsolute(options.path) ? options.path : path.join(options.root || this.root, options.path);
         const statRes = (err, stats) => {
             if (err)
                 return res.error(err);
@@ -1842,7 +1767,7 @@ class StaticPlugin extends Plugin {
                     res.setHeader('Content-Type', this.mimeTypes[path.extname(options.path)] || 'application/octet-stream');
             }
             if (options.filename)
-                res.setHeader('Content-Disposition', 'attachment; filename="' + options.filename + '"');
+                res.setHeader('Content-Disposition', 'attachment; filename="' + (options.filename === true ? path.basename(options.path) : options.filename) + '"');
             if (options.lastModified !== false)
                 res.setHeader('Last-Modified', stats.mtime.toUTCString());
             res.setHeader('Content-Length', stats.size);
@@ -1878,33 +1803,38 @@ class StaticPlugin extends Plugin {
             statRes(null, options.stats);
     }
 }
-/** Default mime types */
-StaticPlugin.mimeTypes = {
-    '.ico': 'image/x-icon',
-    '.htm': 'text/html',
-    '.html': 'text/html',
-    '.txt': 'text/plain',
-    '.js': 'text/javascript',
-    '.json': 'application/json',
-    '.css': 'text/css',
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.svg': 'image/svg+xml',
-    '.mp3': 'audio/mpeg',
-    '.ogg': 'audio/ogg',
-    '.mp4': 'video/mp4',
-    '.pdf': 'application/pdf',
-    '.woff': 'application/x-font-woff',
-    '.woff2': 'application/x-font-woff2',
-    '.ttf': 'application/x-font-ttf',
-    '.gz': 'application/gzip',
-    '.zip': 'application/zip',
-    '.tgz': 'application/gzip',
-};
-MicroServer.plugins.static = StaticPlugin;
 export class ProxyPlugin extends Plugin {
-    constructor(router, options) {
-        super(router);
+    priority = 120;
+    name = 'proxy';
+    /** Default valid headers */
+    static validHeaders = {
+        authorization: true,
+        accept: true,
+        'accept-encoding': true,
+        'accept-language': true,
+        'cache-control': true,
+        cookie: true,
+        'content-type': true,
+        'content-length': true,
+        host: true,
+        referer: true,
+        'if-match': true,
+        'if-none-match': true,
+        'if-modified-since': true,
+        'user-agent': true,
+        date: true,
+        range: true
+    };
+    /** Current valid headers */
+    validHeaders;
+    /** Override headers to forward to remote */
+    headers;
+    /** Remote url */
+    remoteUrl;
+    /** Match regex filter */
+    regex;
+    constructor(options, server) {
+        super();
         if (typeof options !== 'object')
             options = { remote: options };
         if (!options.remote)
@@ -1913,9 +1843,9 @@ export class ProxyPlugin extends Plugin {
         this.regex = options.match ? new RegExp(options.match) : undefined;
         this.headers = options.headers;
         this.validHeaders = { ...ProxyPlugin.validHeaders, ...options?.validHeaders };
-        if (options.path && options.path !== '/') {
+        if (options.path && options.path !== '/' && server) {
             this.handler = undefined;
-            router.use(options.path + '/:path*', this.proxyHandler.bind(this));
+            server.use(options.path + '/:path*', this.proxyHandler.bind(this));
         }
     }
     /** Default proxy handler */
@@ -1985,28 +1915,14 @@ export class ProxyPlugin extends Plugin {
         return this.proxyHandler(req, res, next);
     }
 }
-/** Default valid headers */
-ProxyPlugin.validHeaders = {
-    authorization: true,
-    accept: true,
-    'accept-encoding': true,
-    'accept-language': true,
-    'cache-control': true,
-    cookie: true,
-    'content-type': true,
-    'content-length': true,
-    host: true,
-    referer: true,
-    'if-match': true,
-    'if-none-match': true,
-    'if-modified-since': true,
-    'user-agent': true,
-    date: true,
-    range: true
-};
-MicroServer.plugins.proxy = ProxyPlugin;
 /** Authentication class */
 export class Auth {
+    /** Server request */
+    req;
+    /** Server response */
+    res;
+    /** Authentication options */
+    options;
     constructor(options, req, res) {
         this.options = options;
         this.req = req;
@@ -2146,6 +2062,8 @@ export class Auth {
     }
     /** Get hashed string from user and password */
     static password(usr, psw, salt) {
+        if (psw.length < 128)
+            psw = crypto.createHash('sha512').update(psw).digest('hex');
         if (usr)
             psw = crypto.createHash('sha512').update(usr + '|' + psw).digest('hex');
         if (salt) {
@@ -2256,12 +2174,14 @@ async function login (username, password, salt) {
 }
 */
 /** Authentication plugin */
-class AuthPlugin extends Plugin {
-    constructor(router, options) {
-        super(router);
-        this.name = 'auth';
-        if (router.auth)
-            throw new Error('Auth plugin already initialized');
+export class AuthPlugin extends Plugin {
+    priority = 50;
+    name = 'auth';
+    options;
+    constructor(options, server) {
+        super();
+        if (!server)
+            throw new Error('Server instance is required');
         this.options = {
             mode: 'cookie',
             token: defaultToken,
@@ -2287,11 +2207,11 @@ class AuthPlugin extends Plugin {
             this.options.users = async (usrid, psw) => {
                 const users = this.options.users;
                 const usr = users?.[usrid];
-                if (usr && (psw === undefined || router.auth?.checkPassword(usrid, psw, usr.password || '')))
+                if (usr && (psw === undefined || server.auth?.checkPassword(usrid, psw, usr.password || '')))
                     return usr;
             };
         }
-        router.auth = new Auth(this.options);
+        server.auth = new Auth(this.options);
     }
     /** Authentication middleware */
     async handler(req, res, next) {
@@ -2369,13 +2289,259 @@ class AuthPlugin extends Plugin {
             return next();
     }
 }
-MicroServer.plugins.auth = AuthPlugin;
-/** Create microserver */
-export function create(config) { return new MicroServer(config); }
+// #endregion AuthPlugin
+export class StandardPlugins extends Plugin {
+    constructor(options, server) {
+        super();
+        if (!server)
+            throw new Error('Server instance is required');
+        const config = server.config || {};
+        const use = (plugin, id) => {
+            if (!id)
+                server.use(plugin);
+            else if (id in config)
+                server.use(plugin, config[id]);
+        };
+        use(MethodsPlugin);
+        use(CorsPlugin, 'cors');
+        use(TrustProxyPlugin, 'trustproxy');
+        use(BodyPlugin);
+        use(StaticFilesPlugin, 'static');
+        use(AuthPlugin, 'auth');
+    }
+}
+/**
+ * Controller for dynamic routes
+ *
+ * @example
+ * ```js
+ * class MyController extends Controller {
+ *   static model = MyModel;
+ *   static acl = 'auth';
+ *
+ *   static 'acl:index' = '';
+ *   static 'url:index' = 'GET /index';
+ *   async index (req, res) {
+ *     res.send('Hello World')
+ *   }
+ *
+ *   //function name prefixes translated to HTTP methods:
+ *   //  all => GET, get => GET, insert => POST, post => POST,
+ *   //  update => PUT, put => PUT, delete => DELETE,
+ *   //  modify => PATCH, patch => PATCH,
+ *   //  websocket => internal WebSocket
+ *   // automatic acl will be: class_name + '/' + function_name_prefix
+ *   // automatic url will be: method + ' /' + class_name + '/' + function_name_without_prefix
+ *
+ *   //static 'acl:allUsers' = 'MyController/all';
+ *   //static 'url:allUsers' = 'GET /MyController/Users';
+ *   async allUsers () {
+ *     return ['usr1', 'usr2', 'usr3']
+ *   }
+ *
+ *   //static 'acl:getOrder' = 'MyController/get';
+ *   //static 'url:getOrder' = 'GET /Users/:id/:id1';
+ *   static 'group:getOrder' = 'orders';
+ *   static 'model:getOrder' = OrderModel;
+ *   async getOrder (id: string, id1: string) {
+ *     return {id, extras: id1, type: 'order'}
+ *   }
+ *
+ *   //static 'acl:insertOrder' = 'MyController/insert';
+ *   //static 'url:insertOrder' = 'POST /Users/:id';
+ *   static 'model:insertOrder' = OrderModel;
+ *   async insertOrder (id: string, id1: string) {
+ *     return {id, extras: id1, type: 'order'}
+ *   }
+ *
+ *   static 'acl:POST /login' = '';
+ *   async 'POST /login' () {
+ *     return {id, extras: id1, type: 'order'}
+ *   }
+ * }
+ * ```
+*/
+export class Controller {
+    req;
+    res;
+    get model() {
+        return this.req.model;
+    }
+    constructor(req, res) {
+        this.req = req;
+        this.res = res;
+    }
+    /** Generate routes for this controller */
+    static routes() {
+        const routes = [];
+        const prefix = Object.getOwnPropertyDescriptor(this, 'name')?.enumerable ? this.name + '/' : '';
+        // iterate throught decorators
+        Object.getOwnPropertyNames(this.prototype).forEach(key => {
+            if (key === 'constructor' || key.startsWith('_'))
+                return;
+            const func = this.prototype[key];
+            if (typeof func !== 'function')
+                return;
+            const thisStatic = this;
+            let url = thisStatic['url:' + key];
+            let acl = thisStatic['acl:' + key] ?? thisStatic['acl'];
+            const user = thisStatic['user:' + key] ?? thisStatic['user'];
+            const group = thisStatic['group:' + key] ?? thisStatic['group'];
+            const modelName = thisStatic['model:' + key] ?? thisStatic['model'];
+            let method = '';
+            if (!url)
+                key = key.replaceAll('$', '/');
+            if (!url && key.startsWith('/')) {
+                method = '*';
+                url = key;
+            }
+            let keyMatch = !url && key.match(/^(all|get|put|post|patch|insert|update|modify|delete|websocket)[/_]?([\w_/-]*)$/i);
+            if (keyMatch) {
+                method = keyMatch[1];
+                url = '/' + prefix + keyMatch[2];
+            }
+            keyMatch = !url && key.match(/^([*\w]+) (.+)$/);
+            if (keyMatch) {
+                method = keyMatch[1];
+                url = keyMatch[2].startsWith('/') ? keyMatch[2] : ('/' + prefix + keyMatch[1]);
+            }
+            keyMatch = !method && url?.match(/^([*\w]+) (.+)$/);
+            if (keyMatch) {
+                method = keyMatch[1];
+                url = keyMatch[2].startsWith('/') ? keyMatch[2] : ('/' + prefix + keyMatch[2]);
+            }
+            if (!method)
+                return;
+            let autoAcl = method.toLowerCase();
+            switch (autoAcl) {
+                case '*':
+                    autoAcl = '';
+                    break;
+                case 'post':
+                    autoAcl = 'insert';
+                    break;
+                case 'put':
+                    autoAcl = 'update';
+                    break;
+                case 'patch':
+                    autoAcl = 'modify';
+                    break;
+            }
+            method = method.toUpperCase();
+            switch (method) {
+                case '*':
+                    break;
+                case 'GET':
+                case 'POST':
+                case 'PUT':
+                case 'PATCH':
+                case 'DELETE':
+                case 'WEBSOCKET':
+                    break;
+                case 'ALL':
+                    method = 'GET';
+                    break;
+                case 'INSERT':
+                    method = 'POST';
+                    break;
+                case 'UPDATE':
+                    method = 'PUT';
+                    break;
+                case 'MODIFY':
+                    method = 'PATCH';
+                    break;
+                default:
+                    throw new Error('Invalid url method for: ' + key);
+            }
+            if (user === undefined && group === undefined && acl === undefined)
+                acl = prefix + autoAcl;
+            // add params if not available in url
+            if (func.length && !url.includes(':')) {
+                let args = ['/:id'];
+                for (let i = 1; i < func.length; i++)
+                    args.push('/:id' + i);
+                url += args.join('');
+            }
+            const list = [method + ' ' + url.replace(/\/\//g, '/'), 'response:json'];
+            if (acl)
+                list.push('acl:' + acl);
+            if (user)
+                list.push('user:' + user);
+            if (group)
+                list.push('group:' + group);
+            list.push((req, res) => {
+                res.isJson = true;
+                const obj = new this(req, res);
+                if (modelName) {
+                    req.model = modelName instanceof Model ? modelName : Model.models[modelName];
+                    if (!obj.model)
+                        throw new InvalidData(modelName, 'model');
+                    req.model = Model.dynamic(req.model, { controller: obj });
+                }
+                return func.apply(obj, req.paramsList);
+            });
+            routes.push(list);
+        });
+        return routes;
+    }
+}
+// #endregion Controller
+// #region Worker
+class WorkerJob {
+    _promises = [];
+    _busy = 0;
+    start() {
+        this._busy++;
+    }
+    end() {
+        this._busy--;
+        if (this._busy === 0)
+            for (const resolve of this._promises.splice(0))
+                resolve();
+    }
+    async wait() {
+        if (!this._busy)
+            return;
+        return new Promise(resolve => this._promises.push(resolve));
+    }
+}
+class Worker {
+    _id = 0;
+    _jobs = {};
+    isBusy(id) {
+        const job = this._jobs[id || 'ready'];
+        return !!job?._busy;
+    }
+    startJob(id) {
+        let job = this._jobs[id || 'ready'];
+        if (!job)
+            job = this._jobs[id || 'ready'] = new WorkerJob();
+        job.start();
+    }
+    endJob(id) {
+        const job = this._jobs[id || 'ready'];
+        if (job)
+            job.end();
+    }
+    get nextId() {
+        return (++this._id).toString();
+    }
+    async wait(id) {
+        const job = this._jobs[id || 'ready'];
+        if (!job)
+            return;
+        return job.wait();
+    }
+}
 /** JSON File store */
 export class FileStore {
+    _cache;
+    _dir;
+    _cacheTimeout;
+    _cacheItems;
+    _debounceTimeout;
+    _iter;
     constructor(options) {
-        this._queue = Promise.resolve();
         this._cache = {};
         this._dir = options?.dir || 'data';
         this._cacheTimeout = options?.cacheTimeout || 2000;
@@ -2397,6 +2563,7 @@ export class FileStore {
             }
         }
     }
+    _queue = Promise.resolve();
     async _sync(cb) {
         let r;
         let p = new Promise(resolve => r = resolve);
@@ -2563,6 +2730,8 @@ export class FileStore {
         return new Proxy(data, handler);
     }
 }
+// #endregion FileStore
+// #region Model
 let globalObjectId = crypto.randomBytes(8);
 function newObjectId() {
     for (let i = 7; i >= 0; i--)
@@ -2571,9 +2740,9 @@ function newObjectId() {
     return (new Date().getTime() / 1000 | 0).toString(16) + globalObjectId.toString('hex');
 }
 class ModelCollectionsInternal {
-    constructor() {
-        this._wait = new Promise(resolve => this._ready = resolve);
-    }
+    _ready;
+    _wait = new Promise(resolve => this._ready = resolve);
+    _db;
     set db(db) {
         Promise.resolve(db).then(db => this._ready(this._db = db));
     }
@@ -2588,6 +2757,8 @@ class ModelCollectionsInternal {
 export class Models {
 }
 export class Model {
+    static collections = new ModelCollectionsInternal();
+    static models = {};
     static set db(db) {
         this.collections.db = db;
     }
@@ -2630,10 +2801,14 @@ export class Model {
         this.register(name, inst);
         return inst;
     }
+    /** Model fields description */
+    model;
+    /** Model collection for persistance */
+    collection;
+    /** Custom options */
+    options = {};
     /** Create model acording to description */
     constructor(schema, options) {
-        /** Custom options */
-        this.options = {};
         const model = this.model = {};
         this.options.name = options?.name || this.__proto__.constructor.name;
         this.collection = options?.collection;
@@ -3011,12 +3186,11 @@ export class Model {
         }
     }
 }
-Model.collections = new ModelCollectionsInternal();
-Model.models = {};
 /** Collection factory */
 export class MicroCollectionStore {
+    _collections = new Map();
+    _store;
     constructor(dataPath, storeTimeDelay) {
-        this._collections = new Map();
         if (dataPath)
             this._store = new FileStore({ dir: dataPath.replace(/^\w+:\/\//, ''), debounceTimeout: storeTimeDelay ?? 1000 });
         if (!Model.db)
@@ -3033,6 +3207,11 @@ export class MicroCollectionStore {
 }
 /** minimalistic indexed mongo type collection with persistance for usage with Model */
 export class MicroCollection {
+    /** Collection name */
+    name;
+    /** Collection data */
+    data;
+    _save;
     constructor(options = {}) {
         this.name = options.name || this.constructor.name;
         this.data = options.data || {};
@@ -3197,3 +3376,4 @@ export class MicroCollection {
         return res;
     }
 }
+// #endregion MicroCollection