@maiyunnet/kebab 2.0.0

package/sys/route.js

@@ -0,0 +1,922 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearKebabConfigs = clearKebabConfigs;
+exports.run = run;
+exports.unlinkUploadFiles = unlinkUploadFiles;
+exports.waitCtr = waitCtr;
+exports.trimPost = trimPost;
+exports.getFormData = getFormData;
+const http = __importStar(require("http"));
+const stream = __importStar(require("stream"));
+const ws = __importStar(require("@litert/websocket"));
+const lFs = __importStar(require("~/lib/fs"));
+const lZlib = __importStar(require("~/lib/zlib"));
+const lCore = __importStar(require("~/lib/core"));
+const lText = __importStar(require("~/lib/text"));
+const lTime = __importStar(require("~/lib/time"));
+const lResponse = __importStar(require("~/lib/net/response"));
+const lWs = __importStar(require("~/lib/ws"));
+const sCtr = __importStar(require("./ctr"));
+const kebab = __importStar(require("~/index"));
+let kebabConfigs = {};
+function clearKebabConfigs() {
+    kebabConfigs = {};
+}
+async function run(data) {
+    if (/^(stc\/.*|favicon.\w+?\??.*|apple[\w-]+?\.png\??.*|[\w-]+?\.txt\??.*|[\w-]+?\.html\??.*)/.test(data.path)) {
+        return false;
+    }
+    if (data.res) {
+        data.res.setHeader('expires', 'Mon, 26 Jul 1994 05:00:00 GMT');
+        data.res.setHeader('cache-control', 'no-store');
+    }
+    if (!kebabConfigs[data.rootPath + 'kebab.json']) {
+        const configContent = await lFs.getContent(data.rootPath + 'kebab.json', 'utf8');
+        if (!configContent) {
+            if (data.res) {
+                data.res.setHeader('content-length', 53);
+                data.res.writeHead(500);
+                data.res.end('<h1>500 File kebab.json can not be read</h1><hr>Kebab');
+            }
+            else {
+                data.socket?.destroy();
+            }
+            return true;
+        }
+        kebabConfigs[data.rootPath + 'kebab.json'] = lText.parseJson(configContent);
+        const routeContent = await lFs.getContent(data.rootPath + 'route.json', 'utf8');
+        if (routeContent) {
+            kebabConfigs[data.rootPath + 'kebab.json'].route = lText.parseJson(routeContent);
+        }
+        for (const name in lCore.globalConfig) {
+            if (typeof lCore.globalConfig[name] !== 'object') {
+                if (kebabConfigs[data.rootPath + 'kebab.json'][name] === undefined) {
+                    kebabConfigs[data.rootPath + 'kebab.json'][name] = lCore.globalConfig[name];
+                }
+                continue;
+            }
+            for (const name2 in lCore.globalConfig[name]) {
+                if (kebabConfigs[data.rootPath + 'kebab.json'][name] === undefined) {
+                    kebabConfigs[data.rootPath + 'kebab.json'][name] = {};
+                }
+                if (kebabConfigs[data.rootPath + 'kebab.json'][name][name2] === undefined) {
+                    kebabConfigs[data.rootPath + 'kebab.json'][name][name2] = lCore.globalConfig[name][name2];
+                }
+            }
+        }
+    }
+    const config = {};
+    const configData = kebabConfigs[data.rootPath + 'kebab.json'];
+    for (const name in configData) {
+        config[name] = configData[name];
+    }
+    config.const = {
+        'path': data.path,
+        'qs': data.uri.query ?? '',
+        'startTime': process.hrtime.bigint(),
+        'startMemory': process.memoryUsage().rss,
+        'mobile': data.req.headers['user-agent'] ? data.req.headers['user-agent'].includes('mobile') : false,
+        'wechat': data.req.headers['user-agent'] ? data.req.headers['user-agent'].includes('micromessenger') : false,
+        'https': data.uri.protocol === 'https' ? true : false,
+        'host': data.uri.host ?? '',
+        'hostname': data.uri.hostname ?? '',
+        'hostport': data.uri.port ? parseInt(data.uri.port) : (data.uri.protocol === 'https' ? 443 : 80),
+        'uri': data.uri,
+        'rootPath': data.rootPath,
+        'ctrPath': data.rootPath + 'ctr/',
+        'viewPath': data.rootPath + 'view/',
+        'dataPath': data.rootPath + 'data/',
+        'modPath': data.rootPath + 'mod/',
+        'wsPath': data.rootPath + 'ws/',
+        'urlBase': data.urlBase,
+        'urlStc': data.urlBase + 'stc/',
+        'urlFull': (data.uri.protocol ?? '') + '//' + (data.uri.host ?? '') + data.urlBase,
+        'urlStcFull': ''
+    };
+    config.const.urlStcFull = config.const.urlFull + 'stc/';
+    if (!config.set.staticPath) {
+        config.set.staticPath = config.const.urlStc;
+    }
+    if (!config.set.staticPathFull) {
+        config.set.staticPathFull = config.const.urlStcFull;
+    }
+    let path = data.path;
+    if (path === '') {
+        path = '@';
+    }
+    const param = [];
+    if (config.lang && data.res) {
+        if (path[2] !== '/') {
+            let isDirect = false;
+            if (!path) {
+                if (config.lang.direct.includes('@')) {
+                    isDirect = true;
+                }
+            }
+            else {
+                for (const ditem of config.lang.direct) {
+                    if (!path.startsWith(ditem)) {
+                        continue;
+                    }
+                    isDirect = true;
+                    break;
+                }
+            }
+            if (!isDirect) {
+                const alang = data.req.headers['accept-language']?.toLowerCase() ?? config.lang.list[0];
+                const apath = config.const.path + (config.const.qs ? '?' + config.const.qs : '');
+                for (const lang of config.lang.list) {
+                    let checkLang = lang;
+                    if (lang === 'sc') {
+                        checkLang = 'cn';
+                    }
+                    else if (lang === 'tc') {
+                        checkLang = 'zh';
+                    }
+                    if (!alang.includes(checkLang)) {
+                        continue;
+                    }
+                    data.res.setHeader('location', config.const.urlBase + lang + '/' + apath);
+                    data.res.writeHead(302);
+                    data.res.end('');
+                    return true;
+                }
+                data.res.setHeader('location', config.const.urlBase + config.lang.list[0] + '/' + apath);
+                data.res.writeHead(302);
+                data.res.end('');
+                return true;
+            }
+        }
+        else {
+            param.push(path.slice(0, 2));
+            path = path.slice(3);
+            if (!path) {
+                path = '@';
+            }
+        }
+    }
+    let match = null;
+    let pathLeft = '', pathRight = '';
+    for (const rule in config.route) {
+        const ruleVal = config.route[rule];
+        if ((match = (new RegExp('^' + rule + '$')).exec(path))) {
+            if (data.res) {
+                [pathLeft, pathRight] = getPathLeftRight(ruleVal);
+            }
+            else {
+                pathLeft = getWsCtrName(ruleVal);
+            }
+            for (let i = 1; i < match.length; ++i) {
+                param.push(match[i]);
+            }
+            break;
+        }
+    }
+    if (!match) {
+        if (data.res) {
+            [pathLeft, pathRight] = getPathLeftRight(path);
+        }
+        else {
+            pathLeft = getWsCtrName(path);
+        }
+    }
+    if (pathLeft.startsWith('middle')) {
+        const text = '[Error] Controller not found, path: ' + path + '.';
+        if (data.res) {
+            if (config.route['#404']) {
+                data.res.setHeader('location', lText.urlResolve(config.const.urlBase, config.route['#404']));
+                data.res.writeHead(302);
+                data.res.end('');
+                return true;
+            }
+            data.res.setHeader('content-type', 'text/html; charset=utf-8');
+            data.res.setHeader('content-length', Buffer.byteLength(text));
+            data.res.writeHead(404);
+            data.res.end(text);
+        }
+        else {
+            data.socket?.destroy();
+        }
+        return true;
+    }
+    const get = data.uri.query ? lText.queryParse(data.uri.query) : {};
+    const cookies = {};
+    if (data.req.headers['cookie']) {
+        const hcookies = data.req.headers['cookie'].split(';');
+        for (const cookie of hcookies) {
+            const co = cookie.split('=');
+            cookies[co[0].trim()] = decodeURIComponent(co[1]);
+        }
+    }
+    const headers = {};
+    for (const key in data.req.headers) {
+        headers[key.toLowerCase()] = data.req.headers[key];
+    }
+    headers['authorization'] ??= '';
+    let rtn;
+    if (data.socket && data.req instanceof http.IncomingMessage) {
+        const filePath = config.const.wsPath + pathLeft + '.js';
+        if (!await lFs.isFile(filePath)) {
+            data.socket?.destroy();
+            return true;
+        }
+        const ctrCtr = (await Promise.resolve(`${filePath}`).then(s => __importStar(require(s)))).default;
+        const cctr = new ctrCtr(config, data.req);
+        let wsSocket;
+        try {
+            const options = await cctr.onUpgrade();
+            wsSocket = lWs.createServer(data.req, data.socket, options);
+            cctr.setPrototype('_socket', wsSocket);
+        }
+        catch (e) {
+            await lCore.log(cctr, lText.stringifyJson(e.stack).slice(1, -1), '-error');
+            data.socket.destroy();
+            return true;
+        }
+        cctr.setPrototype('_param', param);
+        cctr.setPrototype('_action', pathRight);
+        cctr.setPrototype('_headers', headers);
+        cctr.setPrototype('_get', get);
+        cctr.setPrototype('_cookie', cookies);
+        await lCore.log(cctr, '', '-visit');
+        try {
+            rtn = await cctr.onLoad();
+        }
+        catch (e) {
+            await lCore.log(cctr, lText.stringifyJson(e.stack).slice(1, -1), '-error');
+            data.socket.destroy();
+            return true;
+        }
+        if (rtn === undefined || rtn === true) {
+            await new Promise(function (resolve) {
+                wsSocket.on('message', async function (msg) {
+                    switch (msg.opcode) {
+                        case ws.EOpcode.CLOSE: {
+                            const r = await cctr['onMessage'](msg.data, msg.opcode);
+                            if (r === false) {
+                                break;
+                            }
+                            wsSocket.end();
+                            break;
+                        }
+                        case ws.EOpcode.PING: {
+                            const r = await cctr['onMessage'](msg.data, msg.opcode);
+                            if (r === false) {
+                                break;
+                            }
+                            wsSocket.pong();
+                            break;
+                        }
+                        case ws.EOpcode.BINARY:
+                        case ws.EOpcode.TEXT: {
+                            try {
+                                const r = await cctr['onMessage'](msg.data, msg.opcode);
+                                if (r === false) {
+                                    break;
+                                }
+                                const wrtn = await cctr['onData'](msg.data, msg.opcode);
+                                if (wrtn === false) {
+                                    wsSocket.end();
+                                    return;
+                                }
+                                if (!wrtn) {
+                                    return;
+                                }
+                                if (wrtn instanceof Buffer) {
+                                    wsSocket.writeBinary(wrtn);
+                                    return;
+                                }
+                                if (typeof wrtn === 'string') {
+                                    if (!wrtn) {
+                                        return;
+                                    }
+                                    wsSocket.writeText(wrtn);
+                                    return;
+                                }
+                                if (typeof wrtn === 'object') {
+                                    wsSocket.writeResult(wrtn);
+                                    return;
+                                }
+                            }
+                            catch (e) {
+                                await lCore.log(cctr, lText.stringifyJson(e.stack).slice(1, -1), '-error');
+                            }
+                            break;
+                        }
+                        default: {
+                        }
+                    }
+                }).on('drain', async () => {
+                    try {
+                        await cctr['onDrain']();
+                    }
+                    catch (e) {
+                        await lCore.log(cctr, lText.stringifyJson(e.stack).slice(1, -1), '-error');
+                    }
+                }).on('error', async (e) => {
+                    await lCore.log(cctr, lText.stringifyJson(e.stack).slice(1, -1), '-error');
+                }).on('close', async () => {
+                    try {
+                        await cctr['onClose']();
+                    }
+                    catch (e) {
+                        await lCore.log(cctr, lText.stringifyJson(e.stack).slice(1, -1), '-error');
+                    }
+                    resolve();
+                });
+            });
+            return true;
+        }
+        if (!wsSocket.ended) {
+            wsSocket.end();
+        }
+        return true;
+    }
+    if (!data.res) {
+        return true;
+    }
+    const middleCtr = (await Promise.resolve(`${config.const.ctrPath + 'middle'}`).then(s => __importStar(require(s)))).default;
+    const middle = new middleCtr(config, data.req, data.res);
+    let cctr = null;
+    if (data.timer) {
+        middle.setPrototype('_timer', data.timer);
+    }
+    middle.setPrototype('_param', param);
+    middle.setPrototype('_action', pathRight);
+    middle.setPrototype('_headers', headers);
+    middle.setPrototype('_get', get);
+    const rawPost = await getPost(data.req);
+    middle.setPrototype('_rawPost', rawPost[1]);
+    middle.setPrototype('_input', rawPost[0]);
+    const post = Object.assign({}, rawPost[1]);
+    trimPost(post);
+    middle.setPrototype('_post', post);
+    try {
+        rtn = await middle.onLoad();
+    }
+    catch (e) {
+        await lCore.log(middle, '(E03)' + lText.stringifyJson(e.stack).slice(1, -1), '-error');
+        data.res.setHeader('content-type', 'text/html; charset=utf-8');
+        data.res.setHeader('content-length', 25);
+        data.res.writeHead(500);
+        data.res.end('<h1>500 Server Error</h1><hr>Kebab');
+        return true;
+    }
+    let cacheTTL = middle.getPrototype('_cacheTTL');
+    let httpCode = middle.getPrototype('_httpCode');
+    if (rtn === undefined || rtn === true) {
+        const filePath = config.const.ctrPath + pathLeft + '.js';
+        if (!await lFs.isFile(filePath)) {
+            const text = '[Error] Controller not found, path: ' + path + '.';
+            if (config.route['#404']) {
+                data.res.setHeader('location', lText.urlResolve(config.const.urlBase, config.route['#404']));
+                data.res.writeHead(302);
+                data.res.end('');
+                return true;
+            }
+            data.res.setHeader('content-type', 'text/html; charset=utf-8');
+            data.res.setHeader('content-length', Buffer.byteLength(text));
+            data.res.writeHead(404);
+            data.res.end(text);
+            return true;
+        }
+        const ctrCtr = (await Promise.resolve(`${filePath}`).then(s => __importStar(require(s)))).default;
+        cctr = new ctrCtr(config, data.req, data.res ?? data.socket);
+        cctr.setPrototype('_timer', middle.getPrototype('_timer'));
+        cctr.setPrototype('_waitInfo', middle.getPrototype('_waitInfo'));
+        cctr.setPrototype('_param', param);
+        cctr.setPrototype('_action', middle.getPrototype('_action'));
+        cctr.setPrototype('_headers', headers);
+        cctr.setPrototype('_get', get);
+        cctr.setPrototype('_rawPost', middle.getPrototype('_rawPost'));
+        cctr.setPrototype('_input', middle.getPrototype('_input'));
+        cctr.setPrototype('_files', middle.getPrototype('_files'));
+        cctr.setPrototype('_post', middle.getPrototype('_post'));
+        cctr.setPrototype('_cookie', cookies);
+        cctr.setPrototype('_jwt', middle.getPrototype('_jwt'));
+        if (!cctr.getPrototype('_sess') && middle.getPrototype('_sess')) {
+            cctr.setPrototype('_session', middle.getPrototype('_session'));
+            cctr.setPrototype('_sess', middle.getPrototype('_sess'));
+        }
+        cctr.setPrototype('_cacheTTL', middle.getPrototype('_cacheTTL'));
+        cctr.setPrototype('_xsrf', middle.getPrototype('_xsrf'));
+        cctr.setPrototype('_httpCode', middle.getPrototype('_httpCode'));
+        await lCore.log(cctr, '', '-visit');
+        if (config.set.mustHttps && !config.const.https) {
+            data.res.setHeader('location', data.req.url ?? '');
+            data.res.writeHead(302);
+            return true;
+        }
+        if (pathRight.startsWith('_') || pathRight === 'onUpgrade' || pathRight === 'onLoad' || pathRight === 'onData' || pathRight === 'onDrain' || pathRight === 'onClose' || pathRight === 'setPrototype' || pathRight === 'getPrototype' || pathRight === 'getAuthorization') {
+            if (config.route['#404']) {
+                data.res.setHeader('location', lText.urlResolve(config.const.urlBase, config.route['#404']));
+                data.res.writeHead(302);
+                data.res.end('');
+                return true;
+            }
+            const text = '[Error] Action not found, path: ' + path + '.';
+            data.res.setHeader('content-type', 'text/html; charset=utf-8');
+            data.res.setHeader('content-length', Buffer.byteLength(text));
+            data.res.writeHead(404);
+            data.res.end(text);
+            return true;
+        }
+        pathRight = pathRight.replace(/-([a-zA-Z0-9])/g, function (t, t1) {
+            return t1.toUpperCase();
+        });
+        if (cctr[pathRight] === undefined) {
+            if (config.route['#404']) {
+                data.res.setHeader('location', lText.urlResolve(config.const.urlBase, config.route['#404']));
+                data.res.writeHead(302);
+                data.res.end('');
+                return true;
+            }
+            const text = '[Error] Action not found, path: ' + path + '.';
+            data.res.setHeader('content-type', 'text/html; charset=utf-8');
+            data.res.setHeader('content-length', Buffer.byteLength(text));
+            data.res.writeHead(404);
+            data.res.end(text);
+            return true;
+        }
+        try {
+            rtn = await cctr.onLoad();
+            if (rtn === undefined || rtn === true) {
+                rtn = await cctr[pathRight]();
+                rtn = await cctr.onUnload(rtn);
+                rtn = await middle.onUnload(rtn);
+                const sess = cctr.getPrototype('_sess');
+                if (sess) {
+                    await sess.update();
+                }
+            }
+            cacheTTL = cctr.getPrototype('_cacheTTL');
+            httpCode = cctr.getPrototype('_httpCode');
+        }
+        catch (e) {
+            await lCore.log(cctr, '(E04)' + lText.stringifyJson(e.stack).slice(1, -1), '-error');
+            data.res.setHeader('content-type', 'text/html; charset=utf-8');
+            data.res.setHeader('content-length', 25);
+            data.res.writeHead(500);
+            data.res.end('<h1>500 Server Error</h1><hr>Kebab');
+            await waitCtr(cctr);
+            return true;
+        }
+    }
+    if (!data.res.headersSent && (cacheTTL > 0)) {
+        data.res.setHeader('expires', lTime.format(0, 'D, d M Y H:i:s', Date.now() + cacheTTL * 1000) + ' GMT');
+        data.res.setHeader('cache-control', 'max-age=' + cacheTTL.toString());
+    }
+    if (httpCode === 0) {
+        httpCode = 200;
+    }
+    if (rtn === undefined || typeof rtn === 'boolean' || rtn === null) {
+        if (data.res.headersSent) {
+        }
+        else {
+            if (data.res.getHeader('location')) {
+                data.res.writeHead(302);
+            }
+            else {
+                data.res.writeHead(httpCode);
+            }
+        }
+        if (!data.res.writableEnded) {
+            data.res.end('');
+        }
+        await waitCtr(cctr ?? middle);
+        return true;
+    }
+    if (typeof rtn === 'string' || rtn instanceof Buffer) {
+        let compress = null;
+        if (!data.res.headersSent) {
+            if (!data.res.getHeader('content-type')) {
+                data.res.setHeader('content-type', 'text/html; charset=utf-8');
+            }
+            if (Buffer.byteLength(rtn) >= 1024) {
+                compress = lZlib.createCompress(data.req.headers['accept-encoding'] ?? '');
+                if (compress) {
+                    data.res.setHeader('content-encoding', compress.type);
+                }
+            }
+            data.res.writeHead(httpCode);
+        }
+        if (!data.res.writableEnded) {
+            if (compress) {
+                compress.compress.write(rtn);
+                compress.compress.pipe(data.res);
+                compress.compress.end();
+            }
+            else {
+                data.res.end(rtn);
+            }
+        }
+    }
+    else if (rtn instanceof stream.Readable || rtn instanceof lResponse.Response) {
+        const stm = rtn instanceof stream.Readable ? rtn : rtn.getStream();
+        let compress = null;
+        if (!data.res.headersSent) {
+            if (!data.res.getHeader('content-type')) {
+                data.res.setHeader('content-type', 'text/html; charset=utf-8');
+            }
+            compress = lZlib.createCompress(data.req.headers['accept-encoding'] ?? '');
+            if (compress) {
+                data.res.setHeader('content-encoding', compress.type);
+            }
+            data.res.writeHead(httpCode);
+        }
+        if (!data.res.writableEnded) {
+            if (compress) {
+                stm.pipe(compress.compress).pipe(data.res);
+            }
+            else {
+                stm.pipe(data.res);
+            }
+        }
+    }
+    else if (typeof rtn === 'object') {
+        if (Array.isArray(rtn)) {
+            if (rtn.length === 0) {
+                if (!data.res.headersSent) {
+                    data.res.writeHead(500);
+                }
+                if (!data.res.writableEnded) {
+                    data.res.end('<h1>500 Internal server error</h1><hr>Kebab');
+                }
+            }
+            else {
+                if (typeof rtn[0] === 'number') {
+                    const json = { 'result': rtn[0] };
+                    if (rtn[1] !== undefined) {
+                        if (typeof rtn[1] === 'object') {
+                            for (let i = 1; i < rtn.length; ++i) {
+                                Object.assign(json, rtn[i]);
+                            }
+                        }
+                        else {
+                            json['msg'] = rtn[1];
+                            for (let i = 2; i < rtn.length; ++i) {
+                                Object.assign(json, rtn[i]);
+                            }
+                        }
+                    }
+                    const writeData = lText.stringifyJson(json);
+                    let compress = null;
+                    if (!data.res.headersSent) {
+                        data.res.setHeader('content-type', 'application/json; charset=utf-8');
+                        if (Buffer.byteLength(writeData) >= 1024) {
+                            compress = lZlib.createCompress(data.req.headers['accept-encoding'] ?? '');
+                            if (compress) {
+                                data.res.setHeader('content-encoding', compress.type);
+                            }
+                        }
+                        data.res.writeHead(httpCode);
+                    }
+                    if (!data.res.writableEnded) {
+                        if (compress) {
+                            compress.compress.write(writeData);
+                            compress.compress.pipe(data.res);
+                            compress.compress.end();
+                        }
+                        else {
+                            data.res.end(writeData);
+                        }
+                    }
+                }
+                else {
+                    let compress = null;
+                    if (!data.res.headersSent) {
+                        if (!data.res.getHeader('content-type')) {
+                            data.res.setHeader('content-type', 'text/html; charset=utf-8');
+                        }
+                        compress = lZlib.createCompress(data.req.headers['accept-encoding'] ?? '');
+                        if (compress) {
+                            data.res.setHeader('content-encoding', compress.type);
+                        }
+                        data.res.writeHead(httpCode);
+                    }
+                    if (!data.res.writableEnded) {
+                        const passThrough = new stream.PassThrough();
+                        if (compress) {
+                            passThrough.pipe(compress.compress).pipe(data.res);
+                        }
+                        else {
+                            passThrough.pipe(data.res);
+                        }
+                        await lCore.passThroughAppend(passThrough, rtn);
+                    }
+                }
+            }
+        }
+        else {
+            const writeData = lText.stringifyJson(rtn);
+            let compress = null;
+            if (!data.res.headersSent) {
+                data.res.setHeader('content-type', 'application/json; charset=utf-8');
+                if (Buffer.byteLength(writeData) >= 1024) {
+                    compress = lZlib.createCompress(data.req.headers['accept-encoding'] ?? '');
+                    if (compress) {
+                        data.res.setHeader('content-encoding', compress.type);
+                    }
+                }
+                data.res.writeHead(httpCode);
+            }
+            if (!data.res.writableEnded) {
+                if (compress) {
+                    compress.compress.write(writeData);
+                    compress.compress.pipe(data.res);
+                    compress.compress.end();
+                }
+                else {
+                    data.res.end(writeData);
+                }
+            }
+        }
+    }
+    else {
+        if (!data.res.headersSent) {
+            data.res.writeHead(500);
+        }
+        if (!data.res.writableEnded) {
+            data.res.end('<h1>500 Internal server error</h1><hr>Kebab');
+        }
+    }
+    await waitCtr(cctr ?? middle);
+    return true;
+}
+function getPathLeftRight(path) {
+    const pathLio = path.lastIndexOf('/');
+    if (pathLio === -1) {
+        return [path, 'index'];
+    }
+    const right = path.slice(pathLio + 1);
+    return [path.slice(0, pathLio), right === '' ? 'index' : right];
+}
+function getWsCtrName(path) {
+    const pathLio = path.lastIndexOf('/');
+    if (pathLio === -1) {
+        return path.toLowerCase();
+    }
+    return path.slice(pathLio + 1).toLowerCase();
+}
+async function unlinkUploadFiles(cctr) {
+    const cfiles = cctr instanceof sCtr.Ctr ? cctr.getPrototype('_files') : cctr;
+    for (const name in cfiles) {
+        let files = cfiles[name];
+        if (!Array.isArray(files)) {
+            files = [files];
+        }
+        for (const file of files) {
+            await lFs.unlink(file.path);
+        }
+    }
+}
+async function waitCtr(cctr) {
+    const waitInfo = cctr.getPrototype('_waitInfo');
+    if (waitInfo.asyncTask.count) {
+        await waitInfo.asyncTask.callback();
+    }
+    if (waitInfo.transaction) {
+        const msg = 'transaction(' + waitInfo.transaction + ') not be closed';
+        lCore.display('[ERROR][ROUTE][WAITCTR] ' + msg + ': ', cctr.getPrototype('_config').const.path);
+        await lCore.log(cctr, msg, '-error');
+    }
+    await unlinkUploadFiles(cctr);
+}
+function trimPost(post) {
+    for (const key in post) {
+        const val = post[key];
+        if (typeof val === 'string') {
+            post[key] = post[key].trim();
+        }
+        else if (typeof val === 'object') {
+            trimPost(post[key]);
+        }
+    }
+}
+function getPost(req) {
+    return new Promise(function (resolve) {
+        const ct = req.headers['content-type'] ?? '';
+        if (ct.includes('form-data')) {
+            resolve(['', {}]);
+            return;
+        }
+        let buffer = Buffer.from('');
+        req.on('data', function (chunk) {
+            buffer = Buffer.concat([buffer, chunk], buffer.length + chunk.length);
+        });
+        req.on('end', function () {
+            const s = buffer.toString();
+            if (!s) {
+                resolve(['', {}]);
+                return;
+            }
+            if (ct.includes('json')) {
+                try {
+                    resolve([s, lText.parseJson(s)]);
+                }
+                catch {
+                    resolve(['', {}]);
+                }
+                return;
+            }
+            resolve([s, lText.queryParse(s)]);
+        });
+    });
+}
+function getFormData(req, events = {}) {
+    return new Promise(function (resolve) {
+        const ct = req.headers['content-type'] ?? '';
+        if (!ct) {
+            resolve({ 'post': {}, 'files': {} });
+            return;
+        }
+        const clio = ct.lastIndexOf('boundary=');
+        if (clio === -1) {
+            resolve({ 'post': {}, 'files': {} });
+            return;
+        }
+        const rtn = {
+            'post': {},
+            'files': {}
+        };
+        const boundary = ct.slice(clio + 9);
+        let buffer = Buffer.from('');
+        let EState;
+        (function (EState) {
+            EState[EState["WAIT"] = 0] = "WAIT";
+            EState[EState["FILE"] = 1] = "FILE";
+            EState[EState["POST"] = 2] = "POST";
+        })(EState || (EState = {}));
+        let state = EState.WAIT;
+        let name = '';
+        let fileName = '';
+        let ftmpName = '';
+        let ftmpStream;
+        let ftmpSize = 0;
+        let writeFileLength = 0;
+        let readEnd = false;
+        req.on('data', function (chunk) {
+            buffer = Buffer.concat([buffer, chunk], buffer.length + chunk.length);
+            while (true) {
+                switch (state) {
+                    case EState.WAIT: {
+                        const io = buffer.indexOf('\r\n\r\n');
+                        if (io === -1) {
+                            return;
+                        }
+                        const head = buffer.subarray(0, io).toString();
+                        buffer = buffer.subarray(io + 4);
+                        let match = /name="(.+?)"/.exec(head);
+                        name = match ? match[1] : '';
+                        match = /filename="(.+?)"/.exec(head);
+                        if (!match) {
+                            state = EState.POST;
+                        }
+                        else {
+                            ++writeFileLength;
+                            state = EState.FILE;
+                            fileName = match[1];
+                            const fr = events.onfilestart?.(name);
+                            if (fr !== true) {
+                                const date = new Date();
+                                ftmpName = date.getUTCFullYear().toString() +
+                                    (date.getUTCMonth() + 1).toString().padStart(2, '0') +
+                                    date.getUTCDate().toString().padStart(2, '0') +
+                                    date.getUTCHours().toString().padStart(2, '0') +
+                                    date.getUTCMinutes().toString().padStart(2, '0') + '_' + lCore.random() + '.ftmp';
+                                ftmpStream = lFs.createWriteStream(kebab.FTMP_CWD + ftmpName);
+                                ftmpSize = 0;
+                            }
+                            else {
+                                ftmpName = '';
+                            }
+                        }
+                        break;
+                    }
+                    case EState.POST: {
+                        const io = buffer.indexOf('\r\n--' + boundary);
+                        if (io === -1) {
+                            return;
+                        }
+                        const val = buffer.subarray(0, io).toString();
+                        if (rtn.post[name]) {
+                            if (Array.isArray(rtn.post[name])) {
+                                rtn.post[name].push(val);
+                            }
+                            else {
+                                rtn.post[name] = [rtn.post[name], val];
+                            }
+                        }
+                        else {
+                            rtn.post[name] = val;
+                        }
+                        state = EState.WAIT;
+                        buffer = buffer.subarray(io + 4 + boundary.length);
+                        break;
+                    }
+                    case EState.FILE: {
+                        const io = buffer.indexOf('\r\n--' + boundary);
+                        if (io === -1) {
+                            const writeBuffer = buffer.subarray(0, -boundary.length - 4);
+                            if (ftmpName === '') {
+                                events.onfiledata?.(writeBuffer);
+                            }
+                            else {
+                                ftmpStream.write(writeBuffer);
+                                ftmpSize += Buffer.byteLength(writeBuffer);
+                            }
+                            buffer = buffer.subarray(-boundary.length - 4);
+                            return;
+                        }
+                        const writeBuffer = buffer.subarray(0, io);
+                        if (ftmpName === '') {
+                            events.onfileend?.();
+                        }
+                        else {
+                            ftmpStream.write(writeBuffer);
+                            ftmpSize += Buffer.byteLength(writeBuffer);
+                            ftmpStream.end(() => {
+                                --writeFileLength;
+                                if (!readEnd) {
+                                    return;
+                                }
+                                if (writeFileLength) {
+                                    return;
+                                }
+                                resolve(rtn);
+                            });
+                            let fname = fileName.replace(/\\/g, '/');
+                            const nlio = fname.lastIndexOf('/');
+                            if (nlio !== -1) {
+                                fname = fname.slice(nlio + 1);
+                            }
+                            const val = {
+                                'name': fname,
+                                'origin': fileName,
+                                'size': ftmpSize,
+                                'path': kebab.FTMP_CWD + ftmpName
+                            };
+                            if (rtn.files[name]) {
+                                if (Array.isArray(rtn.files[name])) {
+                                    rtn.files[name].push(val);
+                                }
+                                else {
+                                    rtn.files[name] = [rtn.files[name], val];
+                                }
+                            }
+                            else {
+                                rtn.files[name] = val;
+                            }
+                        }
+                        state = EState.WAIT;
+                        buffer = buffer.subarray(io + 4 + boundary.length);
+                        break;
+                    }
+                }
+            }
+        });
+        req.on('error', function () {
+            resolve(false);
+        });
+        req.on('end', function () {
+            readEnd = true;
+            if (writeFileLength) {
+                return;
+            }
+            resolve(rtn);
+        });
+    });
+}