sockress 0.2.6 → 0.2.7

package/dist/index.js

@@ -0,0 +1,1267 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = exports.createSockress = exports.SockressApp = exports.SockressAppRoute = exports.SockressRoute = exports.SockressRouter = exports.SockressResponse = exports.SockressRequestImpl = void 0;
+exports.sockress = sockress;
+exports.createUploader = createUploader;
+exports.serveStatic = serveStatic;
+const http_1 = __importDefault(require("http"));
+const tls_1 = require("tls");
+const ws_1 = require("ws");
+const cookie_1 = require("cookie");
+const nanoid_1 = require("nanoid");
+const multer_1 = __importDefault(require("multer"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+class SockressRequestImpl {
+    constructor(id, method, path, query, headers, body, cookies, files, file, type, ip, protocol, secure, raw, originalUrl, baseUrl) {
+        this.id = id;
+        this.method = method;
+        this.path = path;
+        this.query = query;
+        this.headers = headers;
+        this.body = body;
+        this.cookies = cookies;
+        this.files = files;
+        this.file = file;
+        this.type = type;
+        this.ip = ip;
+        this.protocol = protocol;
+        this.secure = secure;
+        this.raw = raw;
+        this.params = {};
+        this.context = {};
+        const host = this.get('host') || '';
+        this.hostname = host.split(':')[0] || undefined;
+        this.originalUrl = originalUrl;
+        this.baseUrl = baseUrl || '';
+        this.subdomains = this.hostname ? extractSubdomains(this.hostname) : [];
+    }
+    get(field) {
+        const key = field.toLowerCase();
+        const value = this.headers[key];
+        if (Array.isArray(value)) {
+            return value[0];
+        }
+        if (typeof value === 'number') {
+            return String(value);
+        }
+        return value;
+    }
+    accepts(types) {
+        const acceptHeader = this.get('accept') || '*/*';
+        const acceptTypes = acceptHeader.split(',').map((t) => t.trim().split(';')[0].toLowerCase());
+        const requestedTypes = Array.isArray(types) ? types : [types];
+        for (const requested of requestedTypes) {
+            const normalized = requested.toLowerCase();
+            if (acceptTypes.includes(normalized) || acceptTypes.includes('*/*')) {
+                return requested;
+            }
+            const mimeType = normalized.includes('/') ? normalized : `application/${normalized}`;
+            if (acceptTypes.some((at) => at === mimeType || at.startsWith(mimeType.split('/')[0] + '/*'))) {
+                return requested;
+            }
+        }
+        return false;
+    }
+    is(type) {
+        const contentType = (this.get('content-type') || '').toLowerCase().split(';')[0].trim();
+        const types = Array.isArray(type) ? type : [type];
+        for (const t of types) {
+            const normalized = t.toLowerCase();
+            if (contentType === normalized || contentType.startsWith(normalized + '/')) {
+                return t;
+            }
+        }
+        return contentType ? false : null;
+    }
+    param(name, defaultValue) {
+        var _a, _b;
+        return (_b = (_a = this.params[name]) !== null && _a !== void 0 ? _a : defaultValue) !== null && _b !== void 0 ? _b : '';
+    }
+}
+exports.SockressRequestImpl = SockressRequestImpl;
+class SockressResponse {
+    constructor(mode, cors, allowedOrigin) {
+        this.mode = mode;
+        this.cors = cors;
+        this.allowedOrigin = allowedOrigin;
+        this.statusCode = 200;
+        this.sent = false;
+        this.headers = {};
+        this.cookies = [];
+        if (mode.kind === 'http') {
+            this.raw = mode.res;
+        }
+    }
+    status(code) {
+        this.statusCode = code;
+        return this;
+    }
+    set(field, value) {
+        this.headers[field.toLowerCase()] = value;
+        return this;
+    }
+    append(field, value) {
+        const current = this.headers[field.toLowerCase()];
+        if (current) {
+            this.headers[field.toLowerCase()] = `${current}, ${value}`;
+        }
+        else {
+            this.headers[field.toLowerCase()] = value;
+        }
+        return this;
+    }
+    cookie(name, value, options = {}) {
+        this.cookies.push((0, cookie_1.serialize)(name, value, options));
+        return this;
+    }
+    clearCookie(name, options = {}) {
+        return this.cookie(name, '', { ...options, maxAge: 0 });
+    }
+    json(payload) {
+        this.set('content-type', 'application/json; charset=utf-8');
+        return this.send(payload);
+    }
+    send(payload) {
+        if (this.sent) {
+            return this;
+        }
+        this.sent = true;
+        if (!this.headers['content-type'] && typeof payload === 'string') {
+            this.set('content-type', 'text/plain; charset=utf-8');
+        }
+        const headersWithCors = this.buildHeaders();
+        if (this.mode.kind === 'http') {
+            const res = this.mode.res;
+            res.statusCode = this.statusCode;
+            Object.entries(headersWithCors).forEach(([key, value]) => {
+                res.setHeader(key, value);
+            });
+            if (this.cookies.length) {
+                res.setHeader('Set-Cookie', this.cookies);
+            }
+            if (Buffer.isBuffer(payload)) {
+                res.end(payload);
+            }
+            else if (typeof payload === 'string') {
+                res.end(payload);
+            }
+            else if (payload === undefined || payload === null) {
+                res.end();
+            }
+            else {
+                const buffer = Buffer.from(JSON.stringify(payload));
+                if (!this.headers['content-type']) {
+                    res.setHeader('content-type', 'application/json; charset=utf-8');
+                }
+                res.end(buffer);
+            }
+            return this;
+        }
+        const message = {
+            type: 'response',
+            id: this.mode.requestId,
+            status: this.statusCode,
+            headers: headersWithCors,
+            body: payload,
+            cookies: this.cookies.length ? [...this.cookies] : undefined
+        };
+        this.mode.socket.send(JSON.stringify(message));
+        return this;
+    }
+    end() {
+        return this.send();
+    }
+    isSent() {
+        return this.sent;
+    }
+    redirect(url, statusOrUrl) {
+        if (typeof url === 'number') {
+            this.statusCode = url;
+            const target = typeof statusOrUrl === 'string' ? statusOrUrl : '/';
+            this.set('Location', target);
+            return this.send();
+        }
+        const status = typeof statusOrUrl === 'number' ? statusOrUrl : 302;
+        this.status(status);
+        this.set('Location', url);
+        return this.send();
+    }
+    sendFile(filePath, options) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const resolvedPath = (options === null || options === void 0 ? void 0 : options.root) ? path_1.default.join(options.root, filePath) : path_1.default.resolve(filePath);
+                const stats = await fs_1.promises.stat(resolvedPath);
+                if (!stats.isFile()) {
+                    reject(new Error('Path is not a file'));
+                    return;
+                }
+                const buffer = await fs_1.promises.readFile(resolvedPath);
+                if (options === null || options === void 0 ? void 0 : options.headers) {
+                    Object.entries(options.headers).forEach(([key, value]) => {
+                        this.set(key, value);
+                    });
+                }
+                this.set('content-type', mimeFromExtension(path_1.default.extname(resolvedPath)));
+                this.set('content-length', stats.size.toString());
+                this.send(buffer);
+                resolve(this);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    download(filePath, filename, options) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                const resolvedPath = (options === null || options === void 0 ? void 0 : options.root) ? path_1.default.join(options.root, filePath) : path_1.default.resolve(filePath);
+                const stats = await fs_1.promises.stat(resolvedPath);
+                if (!stats.isFile()) {
+                    reject(new Error('Path is not a file'));
+                    return;
+                }
+                const buffer = await fs_1.promises.readFile(resolvedPath);
+                const downloadName = filename || path_1.default.basename(resolvedPath);
+                if (options === null || options === void 0 ? void 0 : options.headers) {
+                    Object.entries(options.headers).forEach(([key, value]) => {
+                        this.set(key, value);
+                    });
+                }
+                this.set('content-disposition', `attachment; filename="${downloadName}"`);
+                this.set('content-type', mimeFromExtension(path_1.default.extname(resolvedPath)));
+                this.set('content-length', stats.size.toString());
+                this.send(buffer);
+                resolve(this);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    sendStatus(code) {
+        this.status(code);
+        const statusText = getStatusText(code);
+        return this.send(statusText);
+    }
+    format(obj, req) {
+        if (this.sent)
+            return this;
+        const accept = req.get('accept') || '*/*';
+        const keys = Object.keys(obj);
+        for (const key of keys) {
+            if (accept.includes(key) || key === 'default') {
+                const handler = obj[key];
+                if (handler) {
+                    handler(req, this);
+                    return this;
+                }
+            }
+        }
+        if (obj.default) {
+            obj.default(req, this);
+        }
+        return this;
+    }
+    location(url) {
+        return this.set('Location', url);
+    }
+    vary(field) {
+        const current = this.headers['vary'];
+        if (current) {
+            this.set('Vary', `${current}, ${field}`);
+        }
+        else {
+            this.set('Vary', field);
+        }
+        return this;
+    }
+    buildHeaders() {
+        const headers = { ...this.headers };
+        headers['access-control-allow-origin'] = this.allowedOrigin;
+        headers['access-control-allow-credentials'] = String(this.cors.credentials);
+        headers['access-control-allow-methods'] = this.cors.methods.join(', ');
+        headers['access-control-allow-headers'] = this.cors.allowedHeaders.join(', ');
+        headers['access-control-expose-headers'] = this.cors.exposedHeaders.join(', ');
+        headers['access-control-max-age'] = String(this.cors.maxAge);
+        return headers;
+    }
+}
+exports.SockressResponse = SockressResponse;
+class SockressRouter {
+    constructor() {
+        this.middlewares = [];
+        this.routes = [];
+    }
+    use(pathOrHandler, ...rest) {
+        let path = '/';
+        let stack = [];
+        if (typeof pathOrHandler === 'string') {
+            path = pathOrHandler;
+            stack = rest;
+        }
+        else {
+            stack = [pathOrHandler, ...rest];
+        }
+        if (!stack.length) {
+            throw new Error('use() requires at least one handler');
+        }
+        for (const handler of stack) {
+            if (!handler)
+                continue;
+            this.middlewares.push({
+                path,
+                handler,
+                isErrorHandler: handler.length === 4
+            });
+        }
+        return this;
+    }
+    register(method, path, handlers) {
+        if (!handlers.length) {
+            throw new Error(`Route ${method} ${path} requires at least one handler`);
+        }
+        this.routes.push({
+            method,
+            matcher: buildMatcher(path),
+            handlers
+        });
+        return this;
+    }
+    get(path, ...handlers) {
+        return this.register('GET', path, handlers);
+    }
+    post(path, ...handlers) {
+        return this.register('POST', path, handlers);
+    }
+    put(path, ...handlers) {
+        return this.register('PUT', path, handlers);
+    }
+    patch(path, ...handlers) {
+        return this.register('PATCH', path, handlers);
+    }
+    delete(path, ...handlers) {
+        return this.register('DELETE', path, handlers);
+    }
+    head(path, ...handlers) {
+        return this.register('HEAD', path, handlers);
+    }
+    options(path, ...handlers) {
+        return this.register('OPTIONS', path, handlers);
+    }
+    all(path, ...handlers) {
+        return this.register('ALL', path, handlers);
+    }
+    route(path) {
+        return new SockressRoute(this, path);
+    }
+    getStack() {
+        return { middlewares: this.middlewares, routes: this.routes };
+    }
+}
+exports.SockressRouter = SockressRouter;
+class SockressRoute {
+    constructor(router, path) {
+        this.router = router;
+        this.path = path;
+    }
+    get(...handlers) {
+        this.router.get(this.path, ...handlers);
+        return this;
+    }
+    post(...handlers) {
+        this.router.post(this.path, ...handlers);
+        return this;
+    }
+    put(...handlers) {
+        this.router.put(this.path, ...handlers);
+        return this;
+    }
+    patch(...handlers) {
+        this.router.patch(this.path, ...handlers);
+        return this;
+    }
+    delete(...handlers) {
+        this.router.delete(this.path, ...handlers);
+        return this;
+    }
+    head(...handlers) {
+        this.router.head(this.path, ...handlers);
+        return this;
+    }
+    options(...handlers) {
+        this.router.options(this.path, ...handlers);
+        return this;
+    }
+    all(...handlers) {
+        this.router.all(this.path, ...handlers);
+        return this;
+    }
+}
+exports.SockressRoute = SockressRoute;
+class SockressAppRoute {
+    constructor(app, path) {
+        this.app = app;
+        this.path = path;
+    }
+    get(...handlers) {
+        this.app.get(this.path, ...handlers);
+        return this;
+    }
+    post(...handlers) {
+        this.app.post(this.path, ...handlers);
+        return this;
+    }
+    put(...handlers) {
+        this.app.put(this.path, ...handlers);
+        return this;
+    }
+    patch(...handlers) {
+        this.app.patch(this.path, ...handlers);
+        return this;
+    }
+    delete(...handlers) {
+        this.app.delete(this.path, ...handlers);
+        return this;
+    }
+    head(...handlers) {
+        this.app.head(this.path, ...handlers);
+        return this;
+    }
+    options(...handlers) {
+        this.app.options(this.path, ...handlers);
+        return this;
+    }
+    all(...handlers) {
+        this.app.all(this.path, ...handlers);
+        return this;
+    }
+}
+exports.SockressAppRoute = SockressAppRoute;
+class SockressApp {
+    constructor(config) {
+        this.config = config;
+        this.middlewares = [];
+        this.routes = [];
+        this.paramHandlers = new Map();
+        this.shutdownRegistered = false;
+        this.shuttingDown = false;
+    }
+    static Router() {
+        return new SockressRouter();
+    }
+    static create(options) {
+        return new SockressApp(normalizeOptions(options));
+    }
+    use(pathOrHandler, ...rest) {
+        let path = '/';
+        let stack = [];
+        if (typeof pathOrHandler === 'string') {
+            path = pathOrHandler;
+            stack = rest;
+        }
+        else {
+            stack = [pathOrHandler, ...rest];
+        }
+        if (!stack.length) {
+            throw new Error('use() requires at least one handler');
+        }
+        for (const item of stack) {
+            if (!item)
+                continue;
+            if (item instanceof SockressRouter) {
+                const routerStack = item.getStack();
+                for (const layer of routerStack.middlewares) {
+                    this.middlewares.push({
+                        path: path === '/' ? layer.path : `${path}${layer.path === '/' ? '' : layer.path}`,
+                        handler: layer.handler,
+                        isErrorHandler: layer.isErrorHandler
+                    });
+                }
+                for (const route of routerStack.routes) {
+                    this.routes.push({
+                        method: route.method,
+                        matcher: buildMatcher(path === '/' ? route.matcher.raw : `${path}${route.matcher.raw}`),
+                        handlers: route.handlers
+                    });
+                }
+            }
+            else {
+                this.middlewares.push({
+                    path,
+                    handler: item,
+                    isErrorHandler: item.length === 4
+                });
+            }
+        }
+        return this;
+    }
+    useStatic(route, directory, options) {
+        var _a;
+        const handler = serveStatic(directory, { ...options, stripPrefix: (_a = options === null || options === void 0 ? void 0 : options.stripPrefix) !== null && _a !== void 0 ? _a : route });
+        return this.use(route, handler);
+    }
+    register(method, path, handlers) {
+        if (!handlers.length) {
+            throw new Error(`Route ${method} ${path} requires at least one handler`);
+        }
+        this.routes.push({
+            method,
+            matcher: buildMatcher(path),
+            handlers
+        });
+        return this;
+    }
+    get(path, ...handlers) {
+        return this.register('GET', path, handlers);
+    }
+    post(path, ...handlers) {
+        return this.register('POST', path, handlers);
+    }
+    put(path, ...handlers) {
+        return this.register('PUT', path, handlers);
+    }
+    patch(path, ...handlers) {
+        return this.register('PATCH', path, handlers);
+    }
+    delete(path, ...handlers) {
+        return this.register('DELETE', path, handlers);
+    }
+    head(path, ...handlers) {
+        return this.register('HEAD', path, handlers);
+    }
+    options(path, ...handlers) {
+        return this.register('OPTIONS', path, handlers);
+    }
+    all(path, ...handlers) {
+        return this.register('ALL', path, handlers);
+    }
+    param(name, handler) {
+        this.paramHandlers.set(name, handler);
+        return this;
+    }
+    route(path) {
+        return new SockressAppRoute(this, path);
+    }
+    listen(port, hostOrCallback, maybeCallback) {
+        let host;
+        let callback;
+        if (typeof hostOrCallback === 'function') {
+            callback = hostOrCallback;
+        }
+        else {
+            host = hostOrCallback;
+            callback = maybeCallback;
+        }
+        if (this.server) {
+            throw new Error('Sockress server is already running');
+        }
+        const httpServer = http_1.default.createServer((req, res) => this.handleHttp(req, res));
+        const wss = new ws_1.WebSocketServer({ noServer: true });
+        httpServer.on('upgrade', (req, socket, head) => {
+            var _a;
+            const { pathname } = new URL((_a = req.url) !== null && _a !== void 0 ? _a : '/', `http://${req.headers.host || 'localhost'}`);
+            if (pathname !== this.config.socket.path) {
+                socket.destroy();
+                return;
+            }
+            if (!isOriginAllowed(req.headers.origin, this.config.cors.origin)) {
+                socket.destroy();
+                return;
+            }
+            wss.handleUpgrade(req, socket, head, (ws) => {
+                wss.emit('connection', ws, req);
+            });
+        });
+        wss.on('connection', (socket, req) => this.handleSocket(socket, req));
+        this.server = httpServer;
+        this.wss = wss;
+        const listener = httpServer.listen(port, host, () => {
+            const addressInfo = httpServer.address();
+            if (!addressInfo || typeof addressInfo === 'string') {
+                callback === null || callback === void 0 ? void 0 : callback(null, undefined);
+                return;
+            }
+            callback === null || callback === void 0 ? void 0 : callback(null, enhanceAddressInfo(addressInfo, host));
+        });
+        httpServer.on('error', (err) => callback === null || callback === void 0 ? void 0 : callback(err));
+        this.startHeartbeat();
+        this.registerShutdownHooks();
+        return listener;
+    }
+    async close() {
+        await Promise.all([
+            this.server
+                ? new Promise((resolve, reject) => this.server.close((err) => (err ? reject(err) : resolve())))
+                : Promise.resolve(),
+            this.wss
+                ? new Promise((resolve, reject) => this.wss.close((err) => (err ? reject(err) : resolve())))
+                : Promise.resolve()
+        ]);
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+    }
+    startHeartbeat() {
+        if (!this.wss)
+            return;
+        this.heartbeatInterval = setInterval(() => {
+            var _a;
+            (_a = this.wss) === null || _a === void 0 ? void 0 : _a.clients.forEach((socket) => {
+                if (socket.isAlive === false) {
+                    return socket.terminate();
+                }
+                socket.isAlive = false;
+                socket.ping();
+            });
+        }, this.config.socket.heartbeatInterval);
+    }
+    registerShutdownHooks() {
+        if (this.shutdownRegistered)
+            return;
+        this.shutdownRegistered = true;
+        if (typeof process === 'undefined' || !process.on) {
+            return;
+        }
+        const finalize = () => {
+            if (this.shuttingDown)
+                return;
+            this.shuttingDown = true;
+            this.close().catch(() => undefined);
+        };
+        process.once('beforeExit', finalize);
+        process.once('SIGINT', finalize);
+        process.once('SIGTERM', finalize);
+    }
+    async handleHttp(req, res) {
+        var _a;
+        try {
+            const { method = 'GET' } = req;
+            const url = new URL((_a = req.url) !== null && _a !== void 0 ? _a : '/', `http://${req.headers.host || 'localhost'}`);
+            const path = url.pathname || '/';
+            const query = parseQuery(url.searchParams);
+            const cookies = req.headers.cookie ? (0, cookie_1.parse)(req.headers.cookie) : {};
+            const contentType = (req.headers['content-type'] || '').toLowerCase();
+            const skipBodyParsing = contentType.startsWith('multipart/form-data');
+            let parsedBody;
+            if (!skipBodyParsing) {
+                const body = await readBody(req, this.config.bodyLimit);
+                parsedBody = parseBody(body, req.headers['content-type']);
+            }
+            const normalizedPayload = normalizeBodyPayload(parsedBody);
+            const primaryFile = pickPrimaryFile(normalizedPayload.files);
+            const secure = isSocketEncrypted(req.socket);
+            const originalUrl = req.url || '/';
+            const sockressReq = new SockressRequestImpl((0, nanoid_1.nanoid)(), method.toUpperCase(), path, query, req.headers, normalizedPayload.body, cookies, normalizedPayload.files, primaryFile, 'http', getIp(req), secure ? 'https' : 'http', secure, req, originalUrl, '');
+            const origin = pickOrigin(req.headers.origin, this.config.cors.origin);
+            const sockressRes = new SockressResponse({ kind: 'http', req, res }, this.config.cors, origin);
+            if (sockressReq.method === 'OPTIONS') {
+                sockressRes.status(204).end();
+                return;
+            }
+            await this.runPipeline(sockressReq, sockressRes);
+        }
+        catch (error) {
+            res.statusCode = 500;
+            res.setHeader('content-type', 'application/json; charset=utf-8');
+            res.end(JSON.stringify({ error: 'Internal Server Error', details: error instanceof Error ? error.message : error }));
+        }
+    }
+    handleSocket(socket, req) {
+        socket.isAlive = true;
+        socket.on('pong', () => {
+            socket.isAlive = true;
+        });
+        socket.on('message', async (raw) => {
+            var _a, _b, _c;
+            try {
+                const payload = JSON.parse(raw.toString());
+                if (payload.type !== 'request') {
+                    return socket.send(JSON.stringify({ type: 'error', message: 'Unsupported message type' }));
+                }
+                const path = payload.path || '/';
+                const method = (payload.method || 'GET').toUpperCase();
+                const query = (_a = payload.query) !== null && _a !== void 0 ? _a : {};
+                const headers = normalizeHeaders((_b = payload.headers) !== null && _b !== void 0 ? _b : {});
+                const cookieHeader = headers.cookie;
+                const cookieString = Array.isArray(cookieHeader) ? cookieHeader[0] : cookieHeader;
+                const cookies = typeof cookieString === 'string' ? (0, cookie_1.parse)(cookieString) : {};
+                const secure = isSocketEncrypted(req.socket);
+                const normalizedPayload = normalizeBodyPayload(payload.body);
+                const primaryFile = pickPrimaryFile(normalizedPayload.files);
+                const originalUrl = payload.path || '/';
+                const sockressReq = new SockressRequestImpl((_c = payload.id) !== null && _c !== void 0 ? _c : (0, nanoid_1.nanoid)(), method, path, query, headers, normalizedPayload.body, cookies, normalizedPayload.files, primaryFile, 'socket', getIp(req), secure ? 'wss' : 'ws', secure, undefined, originalUrl, '');
+                const origin = pickOrigin(req.headers.origin, this.config.cors.origin);
+                const sockressRes = new SockressResponse({ kind: 'socket', socket, requestId: sockressReq.id }, this.config.cors, origin);
+                await this.runPipeline(sockressReq, sockressRes);
+            }
+            catch (error) {
+                const outgoing = {
+                    type: 'error',
+                    message: error instanceof Error ? error.message : 'Unexpected socket payload'
+                };
+                socket.send(JSON.stringify(outgoing));
+            }
+        });
+    }
+    async runPipeline(req, res) {
+        const stack = this.composeStack(req, req.method);
+        let idx = 0;
+        const next = async (err) => {
+            const layer = stack[idx++];
+            if (!layer) {
+                if (err) {
+                    this.renderError(err, req, res);
+                }
+                else if (!res.isSent()) {
+                    res.status(404).json({ error: 'Not Found' });
+                }
+                return;
+            }
+            const handler = layer.handler;
+            const isErrorHandler = layer.isErrorHandler;
+            try {
+                if (err) {
+                    if (isErrorHandler) {
+                        await handler(err, req, res, next);
+                    }
+                    else {
+                        await next(err);
+                    }
+                    return;
+                }
+                if (isErrorHandler) {
+                    await next();
+                    return;
+                }
+                await handler(req, res, next);
+            }
+            catch (error) {
+                await next(error);
+            }
+        };
+        await next();
+    }
+    composeStack(req, method) {
+        const { path } = req;
+        const stack = [];
+        for (const layer of this.middlewares) {
+            if (matchesPrefix(layer.path, path)) {
+                stack.push({
+                    handler: layer.handler,
+                    isErrorHandler: layer.isErrorHandler
+                });
+            }
+        }
+        for (const route of this.routes) {
+            if (route.method !== method && route.method !== 'ALL') {
+                continue;
+            }
+            const match = route.matcher.match(path);
+            if (!match)
+                continue;
+            req.params = { ...match.params };
+            for (const [paramName, paramValue] of Object.entries(match.params)) {
+                const paramHandler = this.paramHandlers.get(paramName);
+                if (paramHandler) {
+                    const wrapped = (request, res, next) => {
+                        request.params = { ...match.params };
+                        return paramHandler(request, res, next);
+                    };
+                    stack.push({ handler: wrapped, isErrorHandler: false });
+                }
+            }
+            for (const handler of route.handlers) {
+                const isErrorHandler = handler.length === 4;
+                if (isErrorHandler) {
+                    const wrapped = (err, request, res, next) => {
+                        request.params = { ...match.params };
+                        return handler(err, request, res, next);
+                    };
+                    stack.push({ handler: wrapped, isErrorHandler: true });
+                }
+                else {
+                    const wrapped = (request, res, next) => {
+                        request.params = { ...match.params };
+                        return handler(request, res, next);
+                    };
+                    stack.push({ handler: wrapped, isErrorHandler: false });
+                }
+            }
+        }
+        return stack;
+    }
+    renderError(err, req, res) {
+        if (res.isSent()) {
+            return;
+        }
+        res.status(500).json({
+            error: 'Internal Server Error',
+            details: err instanceof Error ? err.message : err
+        });
+    }
+}
+exports.SockressApp = SockressApp;
+function sockress(options) {
+    return SockressApp.create(options);
+}
+exports.createSockress = sockress;
+exports.Router = SockressApp.Router;
+function normalizeOptions(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
+    const cors = {
+        origin: (_b = (_a = options === null || options === void 0 ? void 0 : options.cors) === null || _a === void 0 ? void 0 : _a.origin) !== null && _b !== void 0 ? _b : '*',
+        credentials: (_d = (_c = options === null || options === void 0 ? void 0 : options.cors) === null || _c === void 0 ? void 0 : _c.credentials) !== null && _d !== void 0 ? _d : true,
+        methods: (_f = (_e = options === null || options === void 0 ? void 0 : options.cors) === null || _e === void 0 ? void 0 : _e.methods) !== null && _f !== void 0 ? _f : ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+        allowedHeaders: (_h = (_g = options === null || options === void 0 ? void 0 : options.cors) === null || _g === void 0 ? void 0 : _g.allowedHeaders) !== null && _h !== void 0 ? _h : ['Content-Type', 'Authorization', 'X-Requested-With'],
+        exposedHeaders: (_k = (_j = options === null || options === void 0 ? void 0 : options.cors) === null || _j === void 0 ? void 0 : _j.exposedHeaders) !== null && _k !== void 0 ? _k : [],
+        maxAge: (_m = (_l = options === null || options === void 0 ? void 0 : options.cors) === null || _l === void 0 ? void 0 : _l.maxAge) !== null && _m !== void 0 ? _m : 600
+    };
+    const socket = {
+        path: (_p = (_o = options === null || options === void 0 ? void 0 : options.socket) === null || _o === void 0 ? void 0 : _o.path) !== null && _p !== void 0 ? _p : '/sockress',
+        heartbeatInterval: (_r = (_q = options === null || options === void 0 ? void 0 : options.socket) === null || _q === void 0 ? void 0 : _q.heartbeatInterval) !== null && _r !== void 0 ? _r : 30000,
+        idleTimeout: (_t = (_s = options === null || options === void 0 ? void 0 : options.socket) === null || _s === void 0 ? void 0 : _s.idleTimeout) !== null && _t !== void 0 ? _t : 120000
+    };
+    const bodyLimit = (_u = options === null || options === void 0 ? void 0 : options.bodyLimit) !== null && _u !== void 0 ? _u : 1000000;
+    return { cors, socket, bodyLimit };
+}
+function buildMatcher(path) {
+    if (path === '*' || path === '/*') {
+        return {
+            raw: path,
+            match: (incoming) => ({ params: { wild: incoming.replace(/^\//, '') } })
+        };
+    }
+    const keys = [];
+    const pattern = path
+        .split('/')
+        .map((segment) => {
+        if (!segment)
+            return '';
+        if (segment.startsWith(':')) {
+            const key = segment.replace(/^:/, '').replace(/\?$/, '');
+            keys.push(key);
+            return segment.endsWith('?') ? '(?:\\/([^/]+))?' : '\\/([^/]+)';
+        }
+        if (segment === '*') {
+            keys.push('wild');
+            return '\\/(.*)';
+        }
+        return `\\/${segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`;
+    })
+        .join('');
+    const regex = new RegExp(`^${pattern || '\\/'}\\/?$`);
+    return {
+        raw: path,
+        match: (incoming) => {
+            const exec = regex.exec(incoming === '' ? '/' : incoming);
+            if (!exec) {
+                return null;
+            }
+            const params = {};
+            keys.forEach((key, index) => {
+                const value = exec[index + 1];
+                if (value !== undefined) {
+                    params[key] = decodeURIComponent(value);
+                }
+            });
+            return { params };
+        }
+    };
+}
+async function readBody(req, limit) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let total = 0;
+        req.on('data', (chunk) => {
+            total += chunk.length;
+            if (total > limit) {
+                reject(new Error('Payload too large'));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => resolve(Buffer.concat(chunks)));
+        req.on('error', (err) => reject(err));
+    });
+}
+function parseBody(buffer, contentType) {
+    if (!buffer.length)
+        return undefined;
+    const type = contentType === null || contentType === void 0 ? void 0 : contentType.split(';')[0].trim().toLowerCase();
+    if (type === 'application/json') {
+        const text = buffer.toString('utf8');
+        return text ? JSON.parse(text) : undefined;
+    }
+    if (type === 'application/x-www-form-urlencoded') {
+        const params = new URLSearchParams(buffer.toString('utf8'));
+        const result = {};
+        for (const [key, value] of params.entries()) {
+            if (result[key]) {
+                const existing = result[key];
+                result[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    return buffer;
+}
+function parseQuery(searchParams) {
+    const result = {};
+    for (const [key, value] of searchParams.entries()) {
+        if (result[key]) {
+            const existing = result[key];
+            result[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function matchesPrefix(base, path) {
+    if (base === '/' || base === '')
+        return true;
+    if (!base.startsWith('/')) {
+        base = `/${base}`;
+    }
+    return path === base || path.startsWith(`${base}/`);
+}
+function getIp(req) {
+    var _a;
+    const forwarded = req.headers['x-forwarded-for'];
+    if (Array.isArray(forwarded)) {
+        return forwarded[0];
+    }
+    if (typeof forwarded === 'string') {
+        return forwarded.split(',')[0].trim();
+    }
+    return (_a = req.socket.remoteAddress) !== null && _a !== void 0 ? _a : undefined;
+}
+function isOriginAllowed(originHeader, allowed) {
+    if (!originHeader || allowed === '*')
+        return true;
+    if (Array.isArray(allowed)) {
+        return allowed.includes(originHeader);
+    }
+    return allowed === originHeader;
+}
+function pickOrigin(requestOrigin, allowed) {
+    var _a;
+    if (allowed === '*')
+        return '*';
+    if (Array.isArray(allowed)) {
+        if (requestOrigin && allowed.includes(requestOrigin)) {
+            return requestOrigin;
+        }
+        return (_a = allowed[0]) !== null && _a !== void 0 ? _a : '*';
+    }
+    return allowed;
+}
+function isSocketEncrypted(socket) {
+    return socket instanceof tls_1.TLSSocket && Boolean(socket.encrypted);
+}
+function normalizeBodyPayload(value) {
+    var _a, _b;
+    if (value &&
+        typeof value === 'object' &&
+        '__formData' in value &&
+        typeof value.__formData === 'object') {
+        const form = (value.__formData || {});
+        const files = convertSerializedFiles((_a = form.files) !== null && _a !== void 0 ? _a : {});
+        const fields = (_b = form.fields) !== null && _b !== void 0 ? _b : {};
+        return {
+            body: fields,
+            files: Object.keys(files).length ? files : undefined
+        };
+    }
+    return { body: value === undefined ? {} : value };
+}
+function convertSerializedFiles(serialized) {
+    const files = {};
+    for (const [field, entries] of Object.entries(serialized)) {
+        files[field] = entries
+            .filter((entry) => typeof entry.data === 'string')
+            .map((entry) => {
+            var _a, _b, _c;
+            return ({
+                fieldName: field,
+                name: (_a = entry.name) !== null && _a !== void 0 ? _a : 'file',
+                type: (_b = entry.type) !== null && _b !== void 0 ? _b : 'application/octet-stream',
+                size: (_c = entry.size) !== null && _c !== void 0 ? _c : Buffer.from(entry.data, 'base64').length,
+                buffer: Buffer.from(entry.data, 'base64'),
+                lastModified: entry.lastModified
+            });
+        });
+    }
+    return files;
+}
+function pickPrimaryFile(files) {
+    if (!files) {
+        return undefined;
+    }
+    const firstKey = Object.keys(files)[0];
+    if (!firstKey)
+        return undefined;
+    const list = files[firstKey];
+    if (!Array.isArray(list) || !list.length)
+        return undefined;
+    return list[0];
+}
+function createUploader(options) {
+    const storage = multer_1.default.memoryStorage();
+    const multerInstance = (0, multer_1.default)({
+        storage,
+        limits: options === null || options === void 0 ? void 0 : options.limits
+    });
+    const resolvedDest = (options === null || options === void 0 ? void 0 : options.dest) ? path_1.default.resolve(options.dest) : undefined;
+    const wrap = (factory) => (...args) => {
+        const middleware = factory(...args);
+        return (req, res, next) => {
+            if (req.type === 'socket') {
+                if (!resolvedDest || !req.files) {
+                    if (!req.file) {
+                        req.file = pickPrimaryFile(req.files);
+                    }
+                    next();
+                    return;
+                }
+                persistFilesToDisk(req.files, resolvedDest, options === null || options === void 0 ? void 0 : options.preserveFilename)
+                    .then(() => {
+                    if (!req.file) {
+                        req.file = pickPrimaryFile(req.files);
+                    }
+                    next();
+                })
+                    .catch(next);
+                return;
+            }
+            if (!req.raw || !res.raw) {
+                next(new Error('Uploads require an HTTP request'));
+                return;
+            }
+            middleware(req.raw, res.raw, (err) => {
+                if (err) {
+                    next(err);
+                    return;
+                }
+                const normalized = normalizeMulterOutput(req.raw);
+                req.body = mergeBodies(req.body, normalized.fields);
+                req.files = normalized.files;
+                req.file = normalized.file;
+                if (!resolvedDest || !req.files) {
+                    next();
+                    return;
+                }
+                persistFilesToDisk(req.files, resolvedDest, options === null || options === void 0 ? void 0 : options.preserveFilename)
+                    .then(() => next())
+                    .catch(next);
+            });
+        };
+    };
+    return {
+        single: (field) => wrap(multerInstance.single.bind(multerInstance))(field),
+        array: (field, maxCount) => wrap(multerInstance.array.bind(multerInstance))(field, maxCount),
+        fields: (defs) => wrap(multerInstance.fields.bind(multerInstance))(defs),
+        any: () => wrap(multerInstance.any.bind(multerInstance))()
+    };
+}
+function serveStatic(root, options) {
+    var _a, _b;
+    const resolvedRoot = path_1.default.resolve(root);
+    const stripPrefix = (options === null || options === void 0 ? void 0 : options.stripPrefix) ? ensureLeadingSlash(options.stripPrefix) : '';
+    const indexFile = (_a = options === null || options === void 0 ? void 0 : options.index) !== null && _a !== void 0 ? _a : 'index.html';
+    const maxAge = (_b = options === null || options === void 0 ? void 0 : options.maxAge) !== null && _b !== void 0 ? _b : 0;
+    return async (req, res, next) => {
+        if (req.method !== 'GET' && req.method !== 'HEAD') {
+            next();
+            return;
+        }
+        let relativePath = req.path || '/';
+        if (stripPrefix && relativePath.startsWith(stripPrefix)) {
+            relativePath = relativePath.slice(stripPrefix.length) || '/';
+        }
+        const sanitized = sanitizeRelativePath(relativePath);
+        let target = path_1.default.join(resolvedRoot, sanitized);
+        try {
+            let stats = await fs_1.promises.stat(target);
+            if (stats.isDirectory()) {
+                target = path_1.default.join(target, indexFile);
+                stats = await fs_1.promises.stat(target);
+            }
+            const buffer = await fs_1.promises.readFile(target);
+            res.set('cache-control', `public, max-age=${Math.floor(maxAge / 1000)}`);
+            res.set('content-length', stats.size.toString());
+            res.set('content-type', mimeFromExtension(path_1.default.extname(target)));
+            if (req.method === 'HEAD') {
+                res.end();
+                return;
+            }
+            res.send(buffer);
+        }
+        catch {
+            next();
+        }
+    };
+}
+function mergeBodies(body, nextBody) {
+    const current = typeof body === 'object' && body !== null ? body : {};
+    return { ...current, ...nextBody };
+}
+function normalizeMulterOutput(req) {
+    var _a;
+    const files = {};
+    const pushFile = (file) => {
+        var _a, _b;
+        if (!file)
+            return;
+        const normalized = {
+            fieldName: file.fieldname || file.name || 'file',
+            name: file.originalname || file.filename || file.fieldname || 'file',
+            type: file.mimetype || 'application/octet-stream',
+            size: (_a = file.size) !== null && _a !== void 0 ? _a : (file.buffer ? file.buffer.length : 0),
+            buffer: (_b = file.buffer) !== null && _b !== void 0 ? _b : Buffer.alloc(0),
+            lastModified: file.lastModified
+        };
+        if (!files[normalized.fieldName]) {
+            files[normalized.fieldName] = [];
+        }
+        files[normalized.fieldName].push(normalized);
+    };
+    if (req.file) {
+        pushFile(req.file);
+    }
+    if (Array.isArray(req.files)) {
+        req.files.forEach(pushFile);
+    }
+    else if (req.files && typeof req.files === 'object') {
+        Object.values(req.files).forEach((entry) => {
+            if (Array.isArray(entry)) {
+                entry.forEach(pushFile);
+            }
+            else {
+                pushFile(entry);
+            }
+        });
+    }
+    return {
+        file: pickPrimaryFile(files),
+        files: Object.keys(files).length ? files : undefined,
+        fields: (_a = req.body) !== null && _a !== void 0 ? _a : {}
+    };
+}
+async function persistFilesToDisk(files, dest, preserveFilename) {
+    if (!Object.keys(files).length)
+        return;
+    await fs_1.promises.mkdir(dest, { recursive: true });
+    for (const list of Object.values(files)) {
+        for (const file of list) {
+            const filename = preserveFilename ? sanitizeFilename(file.name) : `${Date.now()}-${(0, nanoid_1.nanoid)(8)}${path_1.default.extname(file.name || '')}`;
+            const target = path_1.default.join(dest, filename);
+            await fs_1.promises.writeFile(target, file.buffer);
+            file.path = target;
+        }
+    }
+}
+function sanitizeFilename(name) {
+    return name.replace(/[^a-zA-Z0-9.\-_]/g, '_');
+}
+function sanitizeRelativePath(requestPath) {
+    const normalized = path_1.default.normalize(requestPath);
+    if (normalized.startsWith('..')) {
+        return normalized.replace(/^(\.\.(\/|\\|$))+/, '');
+    }
+    return normalized;
+}
+function ensureLeadingSlash(value) {
+    if (!value.startsWith('/')) {
+        return `/${value}`;
+    }
+    return value;
+}
+function mimeFromExtension(ext) {
+    switch (ext.toLowerCase()) {
+        case '.html':
+        case '.htm':
+            return 'text/html; charset=utf-8';
+        case '.css':
+            return 'text/css; charset=utf-8';
+        case '.js':
+        case '.mjs':
+            return 'application/javascript; charset=utf-8';
+        case '.json':
+            return 'application/json; charset=utf-8';
+        case '.png':
+            return 'image/png';
+        case '.jpg':
+        case '.jpeg':
+            return 'image/jpeg';
+        case '.gif':
+            return 'image/gif';
+        case '.svg':
+            return 'image/svg+xml';
+        case '.ico':
+            return 'image/x-icon';
+        default:
+            return 'application/octet-stream';
+    }
+}
+function normalizeHeaders(headers) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (value === undefined || value === null)
+            continue;
+        const headerKey = key.toLowerCase();
+        normalized[headerKey] = Array.isArray(value) ? value.map((entry) => String(entry)) : String(value);
+    }
+    return normalized;
+}
+function enhanceAddressInfo(info, preferredHost) {
+    const hostname = normalizeHostname(preferredHost !== null && preferredHost !== void 0 ? preferredHost : info.address);
+    return {
+        ...info,
+        hostname,
+        url: `http://${hostname}:${info.port}`
+    };
+}
+function normalizeHostname(host) {
+    if (!host)
+        return 'localhost';
+    const lowered = host.toLowerCase();
+    if (lowered === '::' || lowered === '::1' || lowered === '0.0.0.0') {
+        return 'localhost';
+    }
+    return host;
+}
+function extractSubdomains(hostname) {
+    const parts = hostname.split('.');
+    if (parts.length <= 2)
+        return [];
+    return parts.slice(0, -2);
+}
+function getStatusText(code) {
+    const statusTexts = {
+        200: 'OK',
+        201: 'Created',
+        204: 'No Content',
+        301: 'Moved Permanently',
+        302: 'Found',
+        304: 'Not Modified',
+        400: 'Bad Request',
+        401: 'Unauthorized',
+        403: 'Forbidden',
+        404: 'Not Found',
+        500: 'Internal Server Error',
+        502: 'Bad Gateway',
+        503: 'Service Unavailable'
+    };
+    return statusTexts[code] || 'Unknown';
+}
+//# sourceMappingURL=index.js.map