almostnode 0.2.7 → 0.2.8

package/dist/assets/{runtime-worker-B8_LZkBX.js → runtime-worker-D8VYeuKv.js}

@@ -365,6 +365,36 @@
     function generateUUID() {
         return new Array(4).fill(0).map(()=>Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
     }
+    const CHUNK = 8192;
+    function uint8ToBase64(bytes) {
+        const parts = [];
+        for(let i = 0; i < bytes.length; i += CHUNK){
+            parts.push(String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + CHUNK))));
+        }
+        return btoa(parts.join(""));
+    }
+    function base64ToUint8(base64) {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for(let i = 0; i < binary.length; i++){
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes;
+    }
+    function uint8ToHex(bytes) {
+        const hex = new Array(bytes.length);
+        for(let i = 0; i < bytes.length; i++){
+            hex[i] = bytes[i].toString(16).padStart(2, "0");
+        }
+        return hex.join("");
+    }
+    function uint8ToBinaryString(bytes) {
+        const parts = [];
+        for(let i = 0; i < bytes.length; i += CHUNK){
+            parts.push(String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + CHUNK))));
+        }
+        return parts.join("");
+    }
     function createNodeError(code, syscall, path, message) {
         const errno = {
             ENOENT: -2,
@@ -437,11 +467,7 @@
             if (node.type === "file") {
                 let content = "";
                 if (node.content && node.content.length > 0) {
-                    let binary = "";
-                    for(let i = 0; i < node.content.length; i++){
-                        binary += String.fromCharCode(node.content[i]);
-                    }
-                    content = btoa(binary);
+                    content = uint8ToBase64(node.content);
                 }
                 files.push({
                     path,
@@ -463,13 +489,11 @@
         }
         static fromSnapshot(snapshot) {
             const vfs = new VirtualFS();
-            const sortedFiles = [
-                ...snapshot.files
-            ].sort((a, b)=>{
-                const aDepth = a.path.split("/").length;
-                const bDepth = b.path.split("/").length;
-                return aDepth - bDepth;
-            });
+            const sortedFiles = snapshot.files.map((entry, i)=>({
+                    entry,
+                    depth: entry.path.split("/").length,
+                    i
+                })).sort((a, b)=>a.depth - b.depth || a.i - b.i).map((x)=>x.entry);
             for (const entry of sortedFiles){
                 if (entry.path === "/") continue;
                 if (entry.type === "directory") {
@@ -479,11 +503,7 @@
                 } else if (entry.type === "file") {
                     let content;
                     if (entry.content) {
-                        const binary = atob(entry.content);
-                        content = new Uint8Array(binary.length);
-                        for(let i = 0; i < binary.length; i++){
-                            content[i] = binary.charCodeAt(i);
-                        }
+                        content = base64ToUint8(entry.content);
                     } else {
                         content = new Uint8Array(0);
                     }
@@ -954,6 +974,8 @@
         }
         return hash.toString(36);
     }
+    const _decoder$2 = new TextDecoder();
+    const _encoder$1 = new TextEncoder();
     class Dirent {
         name;
         _isDirectory;
@@ -990,17 +1012,13 @@
         Object.defineProperty(buffer, "toString", {
             value: function(encoding) {
                 if (encoding === "utf8" || encoding === "utf-8" || !encoding) {
-                    return new TextDecoder().decode(this);
+                    return _decoder$2.decode(this);
                 }
                 if (encoding === "base64") {
-                    let binary = "";
-                    for(let i = 0; i < this.length; i++){
-                        binary += String.fromCharCode(this[i]);
-                    }
-                    return btoa(binary);
+                    return uint8ToBase64(this);
                 }
                 if (encoding === "hex") {
-                    return Array.from(this).map((b)=>b.toString(16).padStart(2, "0")).join("");
+                    return uint8ToHex(this);
                 }
                 throw new Error(`Unsupported encoding: ${encoding}`);
             },
@@ -1245,7 +1263,7 @@
                         err.errno = -9;
                         throw err;
                     }
-                    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+                    const bytes = typeof data === "string" ? _encoder$1.encode(data) : data;
                     entry.content = new Uint8Array(bytes);
                     entry.position = bytes.length;
                     return;
@@ -1396,7 +1414,7 @@
                 }
                 let data;
                 if (typeof buffer === "string") {
-                    data = new TextEncoder().encode(buffer);
+                    data = _encoder$1.encode(buffer);
                     offset = 0;
                     length = data.length;
                 } else {
@@ -1549,17 +1567,9 @@
         }
         return result || ".";
     }
-    let joinCallCount = 0;
     function join$1(...paths) {
         if (paths.length === 0) return ".";
-        const result = normalize(paths.filter(Boolean).join("/"));
-        if (paths.some((p)=>p && p.includes("_generated"))) {
-            joinCallCount++;
-            if (joinCallCount <= 20) {
-                console.log(`[path.join] (${paths.join(", ")}) -> ${result}`);
-            }
-        }
-        return result;
+        return normalize(paths.filter(Boolean).join("/"));
     }
     function resolve$2(...paths) {
         let resolvedPath = "";
@@ -1569,7 +1579,8 @@
             resolvedPath = path + (resolvedPath ? "/" + resolvedPath : "");
         }
         if (!resolvedPath.startsWith("/")) {
-            resolvedPath = "/" + resolvedPath;
+            const cwd = typeof globalThis !== "undefined" && globalThis.process && typeof globalThis.process.cwd === "function" ? globalThis.process.cwd() : "/";
+            resolvedPath = cwd + (resolvedPath ? "/" + resolvedPath : "");
         }
         return normalize(resolvedPath);
     }
@@ -2064,6 +2075,8 @@
         return proc;
     }
     createProcess();
+    const _encoder = new TextEncoder();
+    const _decoder$1 = new TextDecoder("utf-8");
     class Readable extends EventEmitter {
         _buffer = [];
         _ended = false;
@@ -2435,8 +2448,7 @@
                     }
                     return new BufferPolyfill(bytes2);
                 }
-                const encoder = new TextEncoder();
-                const bytes = encoder.encode(data);
+                const bytes = _encoder.encode(data);
                 return new BufferPolyfill(bytes);
             }
             if (data instanceof ArrayBuffer) {
@@ -2491,40 +2503,23 @@
             if (enc === "hex") {
                 return string.length / 2;
             }
-            return new TextEncoder().encode(string).length;
+            return _encoder.encode(string).length;
         }
         toString(encoding = "utf8") {
             const enc = (encoding || "utf8").toLowerCase();
             if (enc === "base64") {
-                let binary = "";
-                for(let i = 0; i < this.length; i++){
-                    binary += String.fromCharCode(this[i]);
-                }
-                return btoa(binary);
+                return uint8ToBase64(this);
             }
             if (enc === "base64url") {
-                let binary = "";
-                for(let i = 0; i < this.length; i++){
-                    binary += String.fromCharCode(this[i]);
-                }
-                return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+                return uint8ToBase64(this).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
             }
             if (enc === "hex") {
-                let hex = "";
-                for(let i = 0; i < this.length; i++){
-                    hex += this[i].toString(16).padStart(2, "0");
-                }
-                return hex;
+                return uint8ToHex(this);
             }
             if (enc === "latin1" || enc === "binary") {
-                let str = "";
-                for(let i = 0; i < this.length; i++){
-                    str += String.fromCharCode(this[i]);
-                }
-                return str;
+                return uint8ToBinaryString(this);
             }
-            const decoder = new TextDecoder("utf-8");
-            return decoder.decode(this);
+            return _decoder$1.decode(this);
         }
         slice(start, end) {
             return new BufferPolyfill(super.slice(start, end));
@@ -2533,7 +2528,7 @@
             return new BufferPolyfill(super.subarray(start, end));
         }
         write(string, offset) {
-            const bytes = new TextEncoder().encode(string);
+            const bytes = _encoder.encode(string);
             this.set(bytes, offset || 0);
             return bytes.length;
         }
@@ -3161,295 +3156,897 @@
         isIPv4: isIPv4,
         isIPv6: isIPv6
     });
-    class IncomingMessage extends Readable {
-        httpVersion = "1.1";
-        httpVersionMajor = 1;
-        httpVersionMinor = 1;
-        complete = false;
-        headers = {};
-        rawHeaders = [];
-        trailers = {};
-        rawTrailers = [];
-        method;
-        url;
-        statusCode;
-        statusMessage;
-        socket;
-        _body = null;
-        constructor(socket){
-            super();
-            this.socket = socket || new Socket$1();
-        }
-        setTimeout(msecs, callback) {
-            if (callback) {
-                this.once("timeout", callback);
-            }
-            return this;
+    function randomBytes(size) {
+        const array = new Uint8Array(size);
+        crypto.getRandomValues(array);
+        return BufferPolyfill.from(array);
+    }
+    function randomFillSync(buffer, offset, size) {
+        const start = offset || 0;
+        const len = size !== void 0 ? size : buffer.length - start;
+        const view = new Uint8Array(buffer.buffer, buffer.byteOffset + start, len);
+        crypto.getRandomValues(view);
+        return buffer;
+    }
+    function randomUUID() {
+        return crypto.randomUUID();
+    }
+    function randomInt(min, max) {
+        if (max === void 0) {
+            max = min;
+            min = 0;
         }
-        destroy(error) {
-            super.destroy(error);
-            return this;
+        const range = max - min;
+        const array = new Uint32Array(1);
+        crypto.getRandomValues(array);
+        return min + array[0] % range;
+    }
+    function getRandomValues(array) {
+        return crypto.getRandomValues(array);
+    }
+    function createHash(algorithm) {
+        return new Hash(algorithm);
+    }
+    class Hash {
+        algorithm;
+        data = [];
+        constructor(algorithm){
+            this.algorithm = normalizeHashAlgorithm(algorithm);
         }
-        _setBody(body) {
-            if (body === null) {
-                this._body = null;
+        update(data, encoding) {
+            let buffer;
+            if (typeof data === "string") {
+                if (encoding === "base64") {
+                    buffer = BufferPolyfill.from(atob(data));
+                } else {
+                    buffer = BufferPolyfill.from(data);
+                }
             } else {
-                this._body = typeof body === "string" ? BufferPolyfill.from(body) : body;
-            }
-            if (this._body) {
-                this.push(this._body);
+                buffer = data;
             }
-            this.push(null);
-            this.complete = true;
+            this.data.push(buffer);
+            return this;
         }
-        static fromRequest(method, url, headers, body) {
-            const msg = new IncomingMessage();
-            msg.method = method;
-            msg.url = url;
-            msg.headers = {
-                ...headers
-            };
-            for (const [key, value] of Object.entries(headers)){
-                msg.rawHeaders.push(key, value);
-            }
-            if (body) {
-                msg._setBody(body);
-            } else {
-                msg.push(null);
-                msg.complete = true;
-            }
-            return msg;
+        async digestAsync(encoding) {
+            const combined = concatBuffers(this.data);
+            const dataBuffer = new Uint8Array(combined).buffer;
+            const hashBuffer = await crypto.subtle.digest(this.algorithm, dataBuffer);
+            return encodeResult(new Uint8Array(hashBuffer), encoding);
         }
-    }
-    class ServerResponse extends Writable {
-        statusCode = 200;
-        statusMessage = "OK";
-        headersSent = false;
-        finished = false;
-        sendDate = true;
-        socket;
-        _headers = new Map();
-        _body = [];
-        _resolve;
-        constructor(req){
-            super();
-            this.socket = req.socket;
+        digest(encoding) {
+            const combined = concatBuffers(this.data);
+            const hash = syncHash(combined, this.algorithm);
+            return encodeResult(hash, encoding);
         }
-        _setResolver(resolve) {
-            this._resolve = resolve;
+    }
+    function createHmac(algorithm, key) {
+        return new Hmac(algorithm, key);
+    }
+    class Hmac {
+        algorithm;
+        key;
+        data = [];
+        constructor(algorithm, key){
+            this.algorithm = normalizeHashAlgorithm(algorithm);
+            this.key = typeof key === "string" ? BufferPolyfill.from(key) : key;
         }
-        setHeader(name, value) {
-            if (this.headersSent) {
-                throw new Error("Cannot set headers after they are sent");
-            }
-            this._headers.set(name.toLowerCase(), String(value));
+        update(data, encoding) {
+            const buffer = typeof data === "string" ? BufferPolyfill.from(data) : data;
+            this.data.push(buffer);
             return this;
         }
-        getHeader(name) {
-            return this._headers.get(name.toLowerCase());
-        }
-        getHeaders() {
-            const headers = {};
-            for (const [key, value] of this._headers){
-                headers[key] = value;
-            }
-            return headers;
-        }
-        getHeaderNames() {
-            return [
-                ...this._headers.keys()
-            ];
+        async digestAsync(encoding) {
+            const combined = concatBuffers(this.data);
+            const keyBuffer = new Uint8Array(this.key).buffer;
+            const dataBuffer = new Uint8Array(combined).buffer;
+            const cryptoKey = await crypto.subtle.importKey("raw", keyBuffer, {
+                name: "HMAC",
+                hash: this.algorithm
+            }, false, [
+                "sign"
+            ]);
+            const signature = await crypto.subtle.sign("HMAC", cryptoKey, dataBuffer);
+            return encodeResult(new Uint8Array(signature), encoding);
         }
-        hasHeader(name) {
-            return this._headers.has(name.toLowerCase());
+        digest(encoding) {
+            const combined = concatBuffers(this.data);
+            const hash = syncHmac(combined, this.key, this.algorithm);
+            return encodeResult(hash, encoding);
         }
-        removeHeader(name) {
-            if (this.headersSent) {
-                throw new Error("Cannot remove headers after they are sent");
-            }
-            this._headers.delete(name.toLowerCase());
+    }
+    async function pbkdf2Async(password, salt, iterations, keylen, digest) {
+        const passwordBuffer = typeof password === "string" ? BufferPolyfill.from(password) : password instanceof Uint8Array ? password : BufferPolyfill.from(password);
+        const saltBuffer = typeof salt === "string" ? BufferPolyfill.from(salt) : salt instanceof Uint8Array ? salt : BufferPolyfill.from(salt);
+        const passwordArrayBuffer = new Uint8Array(passwordBuffer).buffer;
+        const saltArrayBuffer = new Uint8Array(saltBuffer).buffer;
+        const key = await crypto.subtle.importKey("raw", passwordArrayBuffer, "PBKDF2", false, [
+            "deriveBits"
+        ]);
+        const derivedBits = await crypto.subtle.deriveBits({
+            name: "PBKDF2",
+            salt: saltArrayBuffer,
+            iterations,
+            hash: normalizeHashAlgorithm(digest)
+        }, key, keylen * 8);
+        return BufferPolyfill.from(derivedBits);
+    }
+    function pbkdf2(password, salt, iterations, keylen, digest, callback) {
+        pbkdf2Async(password, salt, iterations, keylen, digest).then((key)=>callback(null, key)).catch((err)=>callback(err, BufferPolyfill.alloc(0)));
+    }
+    function pbkdf2Sync(password, salt, iterations, keylen, digest) {
+        const passwordBuffer = typeof password === "string" ? BufferPolyfill.from(password) : password;
+        const saltBuffer = typeof salt === "string" ? BufferPolyfill.from(salt) : salt;
+        const hashAlg = normalizeHashAlgorithm(digest);
+        let hashLen;
+        if (hashAlg.includes("512")) {
+            hashLen = 64;
+        } else if (hashAlg.includes("384")) {
+            hashLen = 48;
+        } else if (hashAlg.includes("1") || hashAlg === "SHA-1") {
+            hashLen = 20;
+        } else {
+            hashLen = 32;
         }
-        writeHead(statusCode, statusMessageOrHeaders, headers) {
-            this.statusCode = statusCode;
-            if (typeof statusMessageOrHeaders === "string") {
-                this.statusMessage = statusMessageOrHeaders;
-                if (headers) {
-                    for (const [key, value] of Object.entries(headers)){
-                        this.setHeader(key, value);
-                    }
-                }
-            } else if (statusMessageOrHeaders) {
-                for (const [key, value] of Object.entries(statusMessageOrHeaders)){
-                    this.setHeader(key, value);
+        const numBlocks = Math.ceil(keylen / hashLen);
+        const derivedKey = new Uint8Array(numBlocks * hashLen);
+        for(let blockNum = 1; blockNum <= numBlocks; blockNum++){
+            const blockNumBuf = new Uint8Array(4);
+            blockNumBuf[0] = blockNum >>> 24 & 255;
+            blockNumBuf[1] = blockNum >>> 16 & 255;
+            blockNumBuf[2] = blockNum >>> 8 & 255;
+            blockNumBuf[3] = blockNum & 255;
+            const saltWithBlock = new Uint8Array(saltBuffer.length + 4);
+            saltWithBlock.set(saltBuffer);
+            saltWithBlock.set(blockNumBuf, saltBuffer.length);
+            let u = syncHmac(saltWithBlock, passwordBuffer, hashAlg);
+            const block = new Uint8Array(u);
+            for(let i = 1; i < iterations; i++){
+                u = syncHmac(u, passwordBuffer, hashAlg);
+                for(let j = 0; j < block.length; j++){
+                    block[j] ^= u[j];
                 }
             }
-            return this;
+            derivedKey.set(block, (blockNum - 1) * hashLen);
         }
-        write(chunk, encodingOrCallback, callback) {
-            this.headersSent = true;
-            const buffer = typeof chunk === "string" ? BufferPolyfill.from(chunk) : chunk;
-            this._body.push(buffer);
-            const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
-            if (cb) {
-                queueMicrotask(()=>cb(null));
+        return BufferPolyfill.from(derivedKey.slice(0, keylen));
+    }
+    function sign(algorithm, data, key, callback) {
+        const keyInfo = extractKeyInfo(key);
+        const alg = algorithm || keyInfo.algorithm;
+        if (!alg) {
+            const error = new Error("Algorithm must be specified");
+            if (callback) {
+                callback(error, null);
+                return;
             }
-            return true;
+            throw error;
         }
-        end(chunkOrCallback, encodingOrCallback, callback) {
-            if (typeof chunkOrCallback === "function") {
-                callback = chunkOrCallback;
-            } else if (chunkOrCallback !== void 0) {
-                this.write(chunkOrCallback);
-            }
-            if (typeof encodingOrCallback === "function") {
-                callback = encodingOrCallback;
-            }
-            this.headersSent = true;
-            this.finished = true;
-            if (this._resolve) {
-                const headers = {};
-                for (const [key, value] of this._headers){
-                    headers[key] = Array.isArray(value) ? value.join(", ") : value;
-                }
-                this._resolve({
-                    statusCode: this.statusCode,
-                    statusMessage: this.statusMessage,
-                    headers,
-                    body: BufferPolyfill.concat(this._body)
-                });
-            }
-            queueMicrotask(()=>{
-                this.emit("finish");
-                if (callback) callback();
-            });
-            return this;
+        if (callback) {
+            signAsync(alg, data, keyInfo).then((sig)=>callback(null, sig)).catch((err)=>callback(err, null));
+            return;
         }
-        send(data) {
-            if (typeof data === "object" && !BufferPolyfill.isBuffer(data)) {
-                this.setHeader("Content-Type", "application/json");
-                data = JSON.stringify(data);
-            }
-            if (!this.hasHeader("Content-Type")) {
-                this.setHeader("Content-Type", "text/html");
+        const result = signSync(alg, data, keyInfo);
+        return result;
+    }
+    function verify(algorithm, data, key, signature, callback) {
+        const keyInfo = extractKeyInfo(key);
+        const alg = algorithm || keyInfo.algorithm;
+        if (!alg) {
+            const error = new Error("Algorithm must be specified");
+            if (callback) {
+                callback(error, false);
+                return;
             }
-            this.write(typeof data === "string" ? data : data);
-            return this.end();
+            throw error;
         }
-        json(data) {
-            this.setHeader("Content-Type", "application/json");
-            return this.end(JSON.stringify(data));
+        if (callback) {
+            verifyAsync(alg, data, keyInfo, signature).then((result)=>callback(null, result)).catch((err)=>callback(err, false));
+            return;
         }
-        status(code) {
-            this.statusCode = code;
+        return verifySync(alg, data, keyInfo, signature);
+    }
+    function createSign(algorithm) {
+        return new Sign(algorithm);
+    }
+    function createVerify(algorithm) {
+        return new Verify(algorithm);
+    }
+    class Sign extends EventEmitter {
+        algorithm;
+        data = [];
+        constructor(algorithm){
+            super();
+            this.algorithm = algorithm;
+        }
+        update(data, encoding) {
+            const buffer = typeof data === "string" ? BufferPolyfill.from(data) : data;
+            this.data.push(buffer);
             return this;
         }
-        redirect(urlOrStatus, url) {
-            if (typeof urlOrStatus === "number") {
-                this.statusCode = urlOrStatus;
-                this.setHeader("Location", url);
-            } else {
-                this.statusCode = 302;
-                this.setHeader("Location", urlOrStatus);
+        sign(privateKey, outputEncoding) {
+            const combined = concatBuffers(this.data);
+            const keyInfo = extractKeyInfo(privateKey);
+            const signature = signSync(this.algorithm, combined, keyInfo);
+            if (outputEncoding === "base64") {
+                return btoa(String.fromCharCode(...signature));
             }
-            this.end();
-        }
-        _getBody() {
-            return BufferPolyfill.concat(this._body);
-        }
-        _getBodyAsString() {
-            return this._getBody().toString("utf8");
+            if (outputEncoding === "hex") {
+                return Array.from(signature).map((b)=>b.toString(16).padStart(2, "0")).join("");
+            }
+            return signature;
         }
     }
-    let Server$2 = class Server extends EventEmitter {
-        _netServer;
-        _requestListener;
-        _pendingRequests = new Map();
-        listening = false;
-        maxHeadersCount = null;
-        timeout = 0;
-        keepAliveTimeout = 5e3;
-        headersTimeout = 6e4;
-        requestTimeout = 0;
-        constructor(requestListener){
+    class Verify extends EventEmitter {
+        algorithm;
+        data = [];
+        constructor(algorithm){
             super();
-            this._requestListener = requestListener;
-            this._netServer = new Server$3();
-            this._netServer.on("listening", ()=>{
-                this.listening = true;
-                this.emit("listening");
-            });
-            this._netServer.on("close", ()=>{
-                this.listening = false;
-                this.emit("close");
-            });
-            this._netServer.on("error", (err)=>{
-                this.emit("error", err);
-            });
+            this.algorithm = algorithm;
         }
-        listen(portOrOptions, hostOrCallback, callback) {
-            let port;
-            let host;
-            let cb;
-            if (typeof portOrOptions === "number") {
-                port = portOrOptions;
-                if (typeof hostOrCallback === "string") {
-                    host = hostOrCallback;
-                    cb = callback;
+        update(data, encoding) {
+            const buffer = typeof data === "string" ? BufferPolyfill.from(data) : data;
+            this.data.push(buffer);
+            return this;
+        }
+        verify(publicKey, signature, signatureEncoding) {
+            const combined = concatBuffers(this.data);
+            const keyInfo = extractKeyInfo(publicKey);
+            let sig;
+            if (typeof signature === "string") {
+                if (signatureEncoding === "base64") {
+                    sig = BufferPolyfill.from(atob(signature));
+                } else if (signatureEncoding === "hex") {
+                    sig = BufferPolyfill.from(signature.match(/.{2}/g).map((byte)=>parseInt(byte, 16)));
                 } else {
-                    cb = hostOrCallback;
+                    sig = BufferPolyfill.from(signature);
                 }
-            } else if (portOrOptions) {
-                port = portOrOptions.port;
-                host = portOrOptions.host;
-                cb = typeof hostOrCallback === "function" ? hostOrCallback : callback;
+            } else {
+                sig = signature;
             }
-            const originalCb = cb;
-            const self = this;
-            cb = function() {
-                const addr = self._netServer.address();
-                if (addr) {
-                    _registerServer(addr.port, self);
-                }
-                if (originalCb) originalCb();
-            };
-            this._netServer.listen(port, host, cb);
-            return this;
+            return verifySync(this.algorithm, combined, keyInfo, sig);
         }
-        close(callback) {
-            const addr = this._netServer.address();
-            if (addr) {
-                _unregisterServer(addr.port);
-            }
-            this._netServer.close(callback);
-            return this;
+    }
+    class KeyObject {
+        _keyData;
+        _type;
+        _algorithm;
+        constructor(type, keyData, algorithm){
+            this._type = type;
+            this._keyData = keyData;
+            this._algorithm = algorithm;
         }
-        address() {
-            return this._netServer.address();
+        get type() {
+            return this._type;
         }
-        setTimeout(msecs, callback) {
-            this.timeout = msecs || 0;
-            if (callback) {
-                this.on("timeout", callback);
-            }
-            return this;
+        get asymmetricKeyType() {
+            if (this._type === "secret") return void 0;
+            if (this._algorithm?.includes("RSA")) return "rsa";
+            if (this._algorithm?.includes("EC") || this._algorithm?.includes("ES")) return "ec";
+            if (this._algorithm?.includes("Ed")) return "ed25519";
+            return void 0;
         }
-        ref() {
-            this._netServer.ref();
-            return this;
+        get symmetricKeySize() {
+            if (this._type !== "secret") return void 0;
+            if (this._keyData instanceof Uint8Array) {
+                return this._keyData.length * 8;
+            }
+            return void 0;
         }
-        unref() {
-            this._netServer.unref();
-            return this;
+        export(options) {
+            if (this._keyData instanceof Uint8Array) {
+                return BufferPolyfill.from(this._keyData);
+            }
+            throw new Error("Cannot export CryptoKey synchronously");
         }
-        async handleRequest(method, url, headers, body) {
-            return new Promise((resolve, reject)=>{
-                const req = IncomingMessage.fromRequest(method, url, headers, body);
-                const res = new ServerResponse(req);
-                res._setResolver(resolve);
-                const timeoutId = this.timeout ? setTimeout(()=>{
-                    reject(new Error("Request timeout"));
-                }, this.timeout) : null;
-                res.on("finish", ()=>{
+    }
+    function createSecretKey(key, encoding) {
+        const keyBuffer = typeof key === "string" ? BufferPolyfill.from(key, encoding) : key;
+        return new KeyObject("secret", keyBuffer);
+    }
+    function createPublicKey(key) {
+        const keyInfo = extractKeyInfo(key);
+        return new KeyObject("public", keyInfo.keyData, keyInfo.algorithm);
+    }
+    function createPrivateKey(key) {
+        const keyInfo = extractKeyInfo(key);
+        return new KeyObject("private", keyInfo.keyData, keyInfo.algorithm);
+    }
+    function timingSafeEqual(a, b) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        let result = 0;
+        for(let i = 0; i < a.length; i++){
+            result |= a[i] ^ b[i];
+        }
+        return result === 0;
+    }
+    function getCiphers$1() {
+        return [
+            "aes-128-cbc",
+            "aes-256-cbc",
+            "aes-128-gcm",
+            "aes-256-gcm"
+        ];
+    }
+    function getHashes() {
+        return [
+            "sha1",
+            "sha256",
+            "sha384",
+            "sha512"
+        ];
+    }
+    const constants$5 = {
+        SSL_OP_ALL: 0,
+        RSA_PKCS1_PADDING: 1,
+        RSA_PKCS1_OAEP_PADDING: 4,
+        RSA_PKCS1_PSS_PADDING: 6
+    };
+    function normalizeHashAlgorithm(alg) {
+        const normalized = alg.toUpperCase().replace(/[^A-Z0-9]/g, "");
+        switch(normalized){
+            case "SHA1":
+                return "SHA-1";
+            case "SHA256":
+                return "SHA-256";
+            case "SHA384":
+                return "SHA-384";
+            case "SHA512":
+                return "SHA-512";
+            case "MD5":
+                return "MD5";
+            default:
+                return alg;
+        }
+    }
+    function getWebCryptoAlgorithm(nodeAlgorithm) {
+        const alg = nodeAlgorithm.toUpperCase().replace(/[^A-Z0-9]/g, "");
+        if (alg.includes("RSA")) {
+            if (alg.includes("PSS")) {
+                const hash2 = alg.match(/SHA(\d+)/)?.[0] || "SHA-256";
+                return {
+                    name: "RSA-PSS",
+                    hash: `SHA-${hash2.replace("SHA", "")}`
+                };
+            }
+            const hash = alg.match(/SHA(\d+)/)?.[0] || "SHA-256";
+            return {
+                name: "RSASSA-PKCS1-v1_5",
+                hash: `SHA-${hash.replace("SHA", "")}`
+            };
+        }
+        if (alg.startsWith("ES") || alg.includes("ECDSA")) {
+            const bits = alg.match(/\d+/)?.[0] || "256";
+            const hash = bits === "512" ? "SHA-512" : bits === "384" ? "SHA-384" : "SHA-256";
+            return {
+                name: "ECDSA",
+                hash
+            };
+        }
+        if (alg.includes("ED25519") || alg === "EDDSA") {
+            return {
+                name: "Ed25519"
+            };
+        }
+        if (alg.includes("HS") || alg.includes("HMAC")) {
+            const bits = alg.match(/\d+/)?.[0] || "256";
+            return {
+                name: "HMAC",
+                hash: `SHA-${bits}`
+            };
+        }
+        return {
+            name: "RSASSA-PKCS1-v1_5",
+            hash: "SHA-256"
+        };
+    }
+    function extractKeyInfo(key) {
+        if (key instanceof KeyObject) {
+            return {
+                keyData: key._keyData,
+                algorithm: key._algorithm,
+                type: key._type,
+                format: "raw"
+            };
+        }
+        if (typeof key === "object" && "key" in key) {
+            return extractKeyInfo(key.key);
+        }
+        const keyStr = typeof key === "string" ? key : key.toString();
+        if (keyStr.includes("-----BEGIN")) {
+            const isPrivate = keyStr.includes("PRIVATE");
+            const isPublic = keyStr.includes("PUBLIC");
+            const base64 = keyStr.replace(/-----BEGIN [^-]+-----/, "").replace(/-----END [^-]+-----/, "").replace(/\s/g, "");
+            const keyData2 = BufferPolyfill.from(atob(base64));
+            let algorithm;
+            if (keyStr.includes("RSA")) algorithm = "RSA-SHA256";
+            else if (keyStr.includes("EC")) algorithm = "ES256";
+            else if (keyStr.includes("ED25519")) algorithm = "Ed25519";
+            return {
+                keyData: keyData2,
+                algorithm,
+                type: isPrivate ? "private" : isPublic ? "public" : "secret",
+                format: "pem"
+            };
+        }
+        const keyData = typeof key === "string" ? BufferPolyfill.from(key) : key;
+        return {
+            keyData,
+            type: "secret",
+            format: "raw"
+        };
+    }
+    function concatBuffers(buffers) {
+        const totalLength = buffers.reduce((acc, arr)=>acc + arr.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const buf of buffers){
+            result.set(buf, offset);
+            offset += buf.length;
+        }
+        return result;
+    }
+    function encodeResult(data, encoding) {
+        if (encoding === "hex") {
+            return Array.from(data).map((b)=>b.toString(16).padStart(2, "0")).join("");
+        }
+        if (encoding === "base64") {
+            return btoa(String.fromCharCode(...data));
+        }
+        return BufferPolyfill.from(data);
+    }
+    function syncHash(data, algorithm) {
+        let size;
+        if (algorithm.includes("512")) {
+            size = 64;
+        } else if (algorithm.includes("384")) {
+            size = 48;
+        } else if (algorithm.includes("1") || algorithm === "SHA-1") {
+            size = 20;
+        } else {
+            size = 32;
+        }
+        const result = new Uint8Array(size);
+        let h1 = 3735928559;
+        let h2 = 1103547991;
+        for(let i = 0; i < data.length; i++){
+            h1 = Math.imul(h1 ^ data[i], 2654435761);
+            h2 = Math.imul(h2 ^ data[i], 1597334677);
+        }
+        h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+        h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+        for(let i = 0; i < size; i++){
+            const mix = i < size / 2 ? h1 : h2;
+            result[i] = mix >>> i % 4 * 8 & 255;
+            h1 = Math.imul(h1, 1103515245) + 12345;
+            h2 = Math.imul(h2, 1103515245) + 12345;
+        }
+        return result;
+    }
+    function syncHmac(data, key, algorithm) {
+        const combined = new Uint8Array(key.length + data.length);
+        combined.set(key, 0);
+        combined.set(data, key.length);
+        return syncHash(combined, algorithm);
+    }
+    async function signAsync(algorithm, data, keyInfo) {
+        const webCryptoAlg = getWebCryptoAlgorithm(algorithm);
+        try {
+            const cryptoKey = await importKey(keyInfo, webCryptoAlg, [
+                "sign"
+            ]);
+            const signatureAlg = webCryptoAlg.hash ? {
+                name: webCryptoAlg.name,
+                hash: webCryptoAlg.hash
+            } : {
+                name: webCryptoAlg.name
+            };
+            const dataBuffer = new Uint8Array(data).buffer;
+            const signature = await crypto.subtle.sign(signatureAlg, cryptoKey, dataBuffer);
+            return BufferPolyfill.from(signature);
+        } catch (error) {
+            console.warn("WebCrypto sign failed, using fallback:", error);
+            return signSync(algorithm, data, keyInfo);
+        }
+    }
+    async function verifyAsync(algorithm, data, keyInfo, signature) {
+        const webCryptoAlg = getWebCryptoAlgorithm(algorithm);
+        try {
+            const cryptoKey = await importKey(keyInfo, webCryptoAlg, [
+                "verify"
+            ]);
+            const verifyAlg = webCryptoAlg.hash ? {
+                name: webCryptoAlg.name,
+                hash: webCryptoAlg.hash
+            } : {
+                name: webCryptoAlg.name
+            };
+            const sigBuffer = new Uint8Array(signature).buffer;
+            const dataBuffer = new Uint8Array(data).buffer;
+            return await crypto.subtle.verify(verifyAlg, cryptoKey, sigBuffer, dataBuffer);
+        } catch (error) {
+            console.warn("WebCrypto verify failed, using fallback:", error);
+            return verifySync(algorithm, data, keyInfo, signature);
+        }
+    }
+    function signSync(algorithm, data, keyInfo) {
+        const keyData = keyInfo.keyData instanceof Uint8Array ? keyInfo.keyData : new Uint8Array(0);
+        const combined = new Uint8Array(keyData.length + data.length);
+        combined.set(keyData, 0);
+        combined.set(data, keyData.length);
+        const hash = syncHash(combined, algorithm);
+        return BufferPolyfill.from(hash);
+    }
+    function verifySync(algorithm, data, keyInfo, signature) {
+        const expectedSig = signSync(algorithm, data, keyInfo);
+        return timingSafeEqual(BufferPolyfill.from(signature), expectedSig);
+    }
+    async function importKey(keyInfo, algorithm, usages) {
+        if (keyInfo.keyData instanceof CryptoKey) {
+            return keyInfo.keyData;
+        }
+        const keyData = keyInfo.keyData;
+        const keyBuffer = new Uint8Array(keyData).buffer;
+        if (keyInfo.format === "pem") {
+            const format = keyInfo.type === "private" ? "pkcs8" : "spki";
+            const importAlg = algorithm.name === "ECDSA" ? {
+                name: "ECDSA",
+                namedCurve: "P-256"
+            } : algorithm.name === "Ed25519" ? {
+                name: "Ed25519"
+            } : {
+                name: algorithm.name,
+                hash: algorithm.hash || "SHA-256"
+            };
+            return await crypto.subtle.importKey(format, keyBuffer, importAlg, true, usages);
+        }
+        if (keyInfo.type === "secret") {
+            return await crypto.subtle.importKey("raw", keyBuffer, {
+                name: algorithm.name,
+                hash: algorithm.hash
+            }, true, usages);
+        }
+        throw new Error(`Unsupported key format: ${keyInfo.format}`);
+    }
+    var crypto$1 = {
+        randomBytes,
+        randomFillSync,
+        randomUUID,
+        randomInt,
+        getRandomValues,
+        createHash,
+        createHmac,
+        createSign,
+        createVerify,
+        sign,
+        verify,
+        pbkdf2,
+        pbkdf2Sync,
+        timingSafeEqual,
+        getCiphers: getCiphers$1,
+        getHashes,
+        constants: constants$5,
+        KeyObject,
+        createSecretKey,
+        createPublicKey,
+        createPrivateKey
+    };
+    var cryptoShim = Object.freeze({
+        __proto__: null,
+        KeyObject: KeyObject,
+        constants: constants$5,
+        createHash: createHash,
+        createHmac: createHmac,
+        createPrivateKey: createPrivateKey,
+        createPublicKey: createPublicKey,
+        createSecretKey: createSecretKey,
+        createSign: createSign,
+        createVerify: createVerify,
+        default: crypto$1,
+        getCiphers: getCiphers$1,
+        getHashes: getHashes,
+        getRandomValues: getRandomValues,
+        pbkdf2: pbkdf2,
+        pbkdf2Sync: pbkdf2Sync,
+        randomBytes: randomBytes,
+        randomFillSync: randomFillSync,
+        randomInt: randomInt,
+        randomUUID: randomUUID,
+        sign: sign,
+        timingSafeEqual: timingSafeEqual,
+        verify: verify
+    });
+    const _BrowserWebSocket = typeof globalThis.WebSocket === "function" ? globalThis.WebSocket : null;
+    class IncomingMessage extends Readable {
+        httpVersion = "1.1";
+        httpVersionMajor = 1;
+        httpVersionMinor = 1;
+        complete = false;
+        headers = {};
+        rawHeaders = [];
+        trailers = {};
+        rawTrailers = [];
+        method;
+        url;
+        statusCode;
+        statusMessage;
+        socket;
+        _body = null;
+        constructor(socket){
+            super();
+            this.socket = socket || new Socket$1();
+        }
+        setTimeout(msecs, callback) {
+            if (callback) {
+                this.once("timeout", callback);
+            }
+            return this;
+        }
+        destroy(error) {
+            super.destroy(error);
+            return this;
+        }
+        _setBody(body) {
+            if (body === null) {
+                this._body = null;
+            } else {
+                this._body = typeof body === "string" ? BufferPolyfill.from(body) : body;
+            }
+            if (this._body) {
+                this.push(this._body);
+            }
+            this.push(null);
+            this.complete = true;
+        }
+        static fromRequest(method, url, headers, body) {
+            const msg = new IncomingMessage();
+            msg.method = method;
+            msg.url = url;
+            msg.headers = {
+                ...headers
+            };
+            for (const [key, value] of Object.entries(headers)){
+                msg.rawHeaders.push(key, value);
+            }
+            if (body) {
+                msg._setBody(body);
+            } else {
+                msg.push(null);
+                msg.complete = true;
+            }
+            return msg;
+        }
+    }
+    class ServerResponse extends Writable {
+        statusCode = 200;
+        statusMessage = "OK";
+        headersSent = false;
+        finished = false;
+        sendDate = true;
+        socket;
+        _headers = new Map();
+        _body = [];
+        _resolve;
+        constructor(req){
+            super();
+            this.socket = req.socket;
+        }
+        _setResolver(resolve) {
+            this._resolve = resolve;
+        }
+        setHeader(name, value) {
+            if (this.headersSent) {
+                throw new Error("Cannot set headers after they are sent");
+            }
+            this._headers.set(name.toLowerCase(), String(value));
+            return this;
+        }
+        getHeader(name) {
+            return this._headers.get(name.toLowerCase());
+        }
+        getHeaders() {
+            const headers = {};
+            for (const [key, value] of this._headers){
+                headers[key] = value;
+            }
+            return headers;
+        }
+        getHeaderNames() {
+            return [
+                ...this._headers.keys()
+            ];
+        }
+        hasHeader(name) {
+            return this._headers.has(name.toLowerCase());
+        }
+        removeHeader(name) {
+            if (this.headersSent) {
+                throw new Error("Cannot remove headers after they are sent");
+            }
+            this._headers.delete(name.toLowerCase());
+        }
+        writeHead(statusCode, statusMessageOrHeaders, headers) {
+            this.statusCode = statusCode;
+            if (typeof statusMessageOrHeaders === "string") {
+                this.statusMessage = statusMessageOrHeaders;
+                if (headers) {
+                    for (const [key, value] of Object.entries(headers)){
+                        this.setHeader(key, value);
+                    }
+                }
+            } else if (statusMessageOrHeaders) {
+                for (const [key, value] of Object.entries(statusMessageOrHeaders)){
+                    this.setHeader(key, value);
+                }
+            }
+            return this;
+        }
+        write(chunk, encodingOrCallback, callback) {
+            this.headersSent = true;
+            const buffer = typeof chunk === "string" ? BufferPolyfill.from(chunk) : chunk;
+            this._body.push(buffer);
+            const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+            if (cb) {
+                queueMicrotask(()=>cb(null));
+            }
+            return true;
+        }
+        end(chunkOrCallback, encodingOrCallback, callback) {
+            if (typeof chunkOrCallback === "function") {
+                callback = chunkOrCallback;
+            } else if (chunkOrCallback !== void 0) {
+                this.write(chunkOrCallback);
+            }
+            if (typeof encodingOrCallback === "function") {
+                callback = encodingOrCallback;
+            }
+            this.headersSent = true;
+            this.finished = true;
+            if (this._resolve) {
+                const headers = {};
+                for (const [key, value] of this._headers){
+                    headers[key] = Array.isArray(value) ? value.join(", ") : value;
+                }
+                this._resolve({
+                    statusCode: this.statusCode,
+                    statusMessage: this.statusMessage,
+                    headers,
+                    body: BufferPolyfill.concat(this._body)
+                });
+            }
+            queueMicrotask(()=>{
+                this.emit("finish");
+                if (callback) callback();
+            });
+            return this;
+        }
+        send(data) {
+            if (typeof data === "object" && !BufferPolyfill.isBuffer(data)) {
+                this.setHeader("Content-Type", "application/json");
+                data = JSON.stringify(data);
+            }
+            if (!this.hasHeader("Content-Type")) {
+                this.setHeader("Content-Type", "text/html");
+            }
+            this.write(typeof data === "string" ? data : data);
+            return this.end();
+        }
+        json(data) {
+            this.setHeader("Content-Type", "application/json");
+            return this.end(JSON.stringify(data));
+        }
+        status(code) {
+            this.statusCode = code;
+            return this;
+        }
+        redirect(urlOrStatus, url) {
+            if (typeof urlOrStatus === "number") {
+                this.statusCode = urlOrStatus;
+                this.setHeader("Location", url);
+            } else {
+                this.statusCode = 302;
+                this.setHeader("Location", urlOrStatus);
+            }
+            this.end();
+        }
+        _getBody() {
+            return BufferPolyfill.concat(this._body);
+        }
+        _getBodyAsString() {
+            return this._getBody().toString("utf8");
+        }
+    }
+    let Server$2 = class Server extends EventEmitter {
+        _netServer;
+        _requestListener;
+        _pendingRequests = new Map();
+        listening = false;
+        maxHeadersCount = null;
+        timeout = 0;
+        keepAliveTimeout = 5e3;
+        headersTimeout = 6e4;
+        requestTimeout = 0;
+        constructor(requestListener){
+            super();
+            this._requestListener = requestListener;
+            this._netServer = new Server$3();
+            this._netServer.on("listening", ()=>{
+                this.listening = true;
+                this.emit("listening");
+            });
+            this._netServer.on("close", ()=>{
+                this.listening = false;
+                this.emit("close");
+            });
+            this._netServer.on("error", (err)=>{
+                this.emit("error", err);
+            });
+        }
+        listen(portOrOptions, hostOrCallback, callback) {
+            let port;
+            let host;
+            let cb;
+            if (typeof portOrOptions === "number") {
+                port = portOrOptions;
+                if (typeof hostOrCallback === "string") {
+                    host = hostOrCallback;
+                    cb = callback;
+                } else {
+                    cb = hostOrCallback;
+                }
+            } else if (portOrOptions) {
+                port = portOrOptions.port;
+                host = portOrOptions.host;
+                cb = typeof hostOrCallback === "function" ? hostOrCallback : callback;
+            }
+            const originalCb = cb;
+            const self = this;
+            cb = function() {
+                const addr = self._netServer.address();
+                if (addr) {
+                    _registerServer(addr.port, self);
+                }
+                if (originalCb) originalCb();
+            };
+            this._netServer.listen(port, host, cb);
+            return this;
+        }
+        close(callback) {
+            const addr = this._netServer.address();
+            if (addr) {
+                _unregisterServer(addr.port);
+            }
+            this._netServer.close(callback);
+            return this;
+        }
+        address() {
+            return this._netServer.address();
+        }
+        setTimeout(msecs, callback) {
+            this.timeout = msecs || 0;
+            if (callback) {
+                this.on("timeout", callback);
+            }
+            return this;
+        }
+        ref() {
+            this._netServer.ref();
+            return this;
+        }
+        unref() {
+            this._netServer.unref();
+            return this;
+        }
+        async handleRequest(method, url, headers, body) {
+            return new Promise((resolve, reject)=>{
+                const req = IncomingMessage.fromRequest(method, url, headers, body);
+                const res = new ServerResponse(req);
+                res._setResolver(resolve);
+                const timeoutId = this.timeout ? setTimeout(()=>{
+                    reject(new Error("Request timeout"));
+                }, this.timeout) : null;
+                res.on("finish", ()=>{
                     if (timeoutId) clearTimeout(timeoutId);
                 });
                 try {
@@ -3584,10 +4181,22 @@
             if (this._aborted) return;
             try {
                 const protocol = this._protocol === "https" ? "https:" : "http:";
-                const hostname = this._options.hostname || "localhost";
-                const port = this._options.port ? `:${this._options.port}` : "";
+                let hostname = this._options.hostname || "";
+                let port = this._options.port ? `:${this._options.port}` : "";
+                if (!hostname && this._options.host) {
+                    const hostParts = this._options.host.split(":");
+                    hostname = hostParts[0];
+                    if (!port && hostParts[1]) {
+                        port = `:${hostParts[1]}`;
+                    }
+                }
+                if (!hostname) hostname = "localhost";
                 const path = this._options.path || "/";
                 const url = `${protocol}//${hostname}${port}${path}`;
+                if (this.headers["upgrade"]?.toLowerCase() === "websocket") {
+                    this._handleWebSocketUpgrade(url);
+                    return;
+                }
                 const corsProxy = getCorsProxy();
                 const fetchUrl = corsProxy ? corsProxy + encodeURIComponent(url) : url;
                 const fetchOptions = {
@@ -3621,20 +4230,134 @@
                 if (error instanceof Error && error.name === "AbortError") {
                     return;
                 }
-                this.emit("error", error);
-            }
-        }
-        async _responseToIncomingMessage(response) {
-            const msg = new IncomingMessage();
-            msg.statusCode = response.status;
-            msg.statusMessage = response.statusText || STATUS_CODES[response.status] || "";
-            response.headers.forEach((value, key)=>{
-                msg.headers[key.toLowerCase()] = value;
-                msg.rawHeaders.push(key, value);
-            });
-            const body = await response.arrayBuffer();
-            msg._setBody(BufferPolyfill.from(body));
-            return msg;
+                this.emit("error", error);
+            }
+        }
+        async _responseToIncomingMessage(response) {
+            const msg = new IncomingMessage();
+            msg.statusCode = response.status;
+            msg.statusMessage = response.statusText || STATUS_CODES[response.status] || "";
+            response.headers.forEach((value, key)=>{
+                msg.headers[key.toLowerCase()] = value;
+                msg.rawHeaders.push(key, value);
+            });
+            const body = await response.arrayBuffer();
+            msg._setBody(BufferPolyfill.from(body));
+            return msg;
+        }
+        _handleWebSocketUpgrade(url) {
+            const wsUrl = url.replace(/^https:/, "wss:").replace(/^http:/, "ws:");
+            const wsKey = this.headers["sec-websocket-key"] || "";
+            const NativeWS = _BrowserWebSocket;
+            if (!NativeWS) {
+                setTimeout(()=>{
+                    this.emit("error", new TypeError("Failed to fetch"));
+                }, 0);
+                return;
+            }
+            const GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+            const acceptValue = createHash("sha1").update(wsKey + GUID).digest("base64");
+            let nativeWs;
+            try {
+                nativeWs = new NativeWS(wsUrl);
+                nativeWs.binaryType = "arraybuffer";
+            } catch (e) {
+                setTimeout(()=>{
+                    this.emit("error", e instanceof Error ? e : new Error(String(e)));
+                }, 0);
+                return;
+            }
+            const socket = new Socket$1();
+            if (typeof socket.cork !== "function") socket.cork = ()=>{};
+            if (typeof socket.uncork !== "function") socket.uncork = ()=>{};
+            socket._readableState = {
+                endEmitted: false
+            };
+            socket._writableState = {
+                finished: false,
+                errorEmitted: false
+            };
+            let writeBuffer = new Uint8Array(0);
+            socket.write = (chunk, encodingOrCallback, callback)=>{
+                const data = typeof chunk === "string" ? BufferPolyfill.from(chunk) : new Uint8Array(chunk);
+                const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+                const newBuf = new Uint8Array(writeBuffer.length + data.length);
+                newBuf.set(writeBuffer, 0);
+                newBuf.set(data, writeBuffer.length);
+                writeBuffer = newBuf;
+                while(writeBuffer.length >= 2){
+                    const parsed = _parseWsFrame(writeBuffer);
+                    if (!parsed) break;
+                    const { opcode, payload, totalLength } = parsed;
+                    writeBuffer = writeBuffer.slice(totalLength);
+                    if (nativeWs.readyState !== NativeWS.OPEN) continue;
+                    if (opcode === 8) {
+                        nativeWs.close();
+                    } else if (opcode === 9) {
+                        nativeWs.send(payload);
+                    } else if (opcode === 10) ;
+                    else if (opcode === 1) {
+                        const text = new TextDecoder().decode(payload);
+                        nativeWs.send(text);
+                    } else if (opcode === 2) {
+                        nativeWs.send(payload);
+                    }
+                }
+                if (cb) queueMicrotask(()=>cb(null));
+                return true;
+            };
+            nativeWs.onopen = ()=>{
+                const response = new IncomingMessage(socket);
+                response.statusCode = 101;
+                response.statusMessage = "Switching Protocols";
+                response.headers = {
+                    "upgrade": "websocket",
+                    "connection": "Upgrade",
+                    "sec-websocket-accept": acceptValue
+                };
+                response.complete = true;
+                response.push(null);
+                this.emit("upgrade", response, socket, BufferPolyfill.alloc(0));
+            };
+            nativeWs.onmessage = (event)=>{
+                let payload;
+                let opcode;
+                if (typeof event.data === "string") {
+                    payload = new TextEncoder().encode(event.data);
+                    opcode = 1;
+                } else if (event.data instanceof ArrayBuffer) {
+                    payload = new Uint8Array(event.data);
+                    opcode = 2;
+                } else {
+                    return;
+                }
+                const frame = _createWsFrame(opcode, payload, false);
+                socket._receiveData(BufferPolyfill.from(frame));
+            };
+            nativeWs.onclose = (event)=>{
+                const code = event.code || 1e3;
+                const closePayload = new Uint8Array(2);
+                closePayload[0] = code >> 8 & 255;
+                closePayload[1] = code & 255;
+                const frame = _createWsFrame(8, closePayload, false);
+                socket._receiveData(BufferPolyfill.from(frame));
+                setTimeout(()=>{
+                    socket._readableState.endEmitted = true;
+                    socket._receiveEnd();
+                    socket.emit("close", false);
+                }, 10);
+            };
+            nativeWs.onerror = ()=>{
+                socket.emit("error", new Error("WebSocket connection error"));
+                socket.destroy();
+            };
+            const origDestroy = socket.destroy.bind(socket);
+            socket.destroy = (error)=>{
+                if (nativeWs.readyState === NativeWS.OPEN || nativeWs.readyState === NativeWS.CONNECTING) {
+                    nativeWs.close();
+                }
+                return origDestroy(error);
+            };
         }
     }
     function parseRequestArgs(urlOrOptions, optionsOrCallback, callback) {
@@ -3760,6 +4483,94 @@
         }
     }
     const globalAgent = new Agent();
+    function _parseWsFrame(data) {
+        if (data.length < 2) return null;
+        const opcode = data[0] & 15;
+        const masked = (data[1] & 128) !== 0;
+        let payloadLength = data[1] & 127;
+        let offset = 2;
+        if (payloadLength === 126) {
+            if (data.length < 4) return null;
+            payloadLength = data[2] << 8 | data[3];
+            offset = 4;
+        } else if (payloadLength === 127) {
+            if (data.length < 10) return null;
+            payloadLength = data[6] << 24 | data[7] << 16 | data[8] << 8 | data[9];
+            offset = 10;
+        }
+        if (masked) {
+            if (data.length < offset + 4 + payloadLength) return null;
+            const maskKey = data.slice(offset, offset + 4);
+            offset += 4;
+            const payload = new Uint8Array(payloadLength);
+            for(let i = 0; i < payloadLength; i++){
+                payload[i] = data[offset + i] ^ maskKey[i % 4];
+            }
+            return {
+                opcode,
+                payload,
+                totalLength: offset + payloadLength
+            };
+        } else {
+            if (data.length < offset + payloadLength) return null;
+            const payload = data.slice(offset, offset + payloadLength);
+            return {
+                opcode,
+                payload,
+                totalLength: offset + payloadLength
+            };
+        }
+    }
+    function _createWsFrame(opcode, payload, masked) {
+        const length = payload.length;
+        let headerSize = 2;
+        if (length > 125 && length <= 65535) {
+            headerSize += 2;
+        } else if (length > 65535) {
+            headerSize += 8;
+        }
+        if (masked) {
+            headerSize += 4;
+        }
+        const frame = new Uint8Array(headerSize + length);
+        frame[0] = 128 | opcode;
+        let offset = 2;
+        if (length <= 125) {
+            frame[1] = (masked ? 128 : 0) | length;
+        } else if (length <= 65535) {
+            frame[1] = (masked ? 128 : 0) | 126;
+            frame[2] = length >> 8 & 255;
+            frame[3] = length & 255;
+            offset = 4;
+        } else {
+            frame[1] = (masked ? 128 : 0) | 127;
+            frame[2] = 0;
+            frame[3] = 0;
+            frame[4] = 0;
+            frame[5] = 0;
+            frame[6] = length >> 24 & 255;
+            frame[7] = length >> 16 & 255;
+            frame[8] = length >> 8 & 255;
+            frame[9] = length & 255;
+            offset = 10;
+        }
+        if (masked) {
+            const maskKey = new Uint8Array(4);
+            if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+                crypto.getRandomValues(maskKey);
+            } else {
+                for(let i = 0; i < 4; i++)maskKey[i] = Math.floor(Math.random() * 256);
+            }
+            frame.set(maskKey, offset);
+            offset += 4;
+            for(let i = 0; i < length; i++){
+                frame[offset + i] = payload[i] ^ maskKey[i % 4];
+            }
+        } else {
+            frame.set(payload, offset);
+        }
+        return frame;
+    }
     var http = {
         Server: Server$2,
         IncomingMessage,
@@ -3776,7 +4587,9 @@
         setServerCloseCallback,
         _createClientRequest,
         Agent,
-        globalAgent
+        globalAgent,
+        _parseWsFrame,
+        _createWsFrame
     };
     var httpShim = Object.freeze({
         __proto__: null,
@@ -3788,6 +4601,8 @@
         Server: Server$2,
         ServerResponse: ServerResponse,
         _createClientRequest: _createClientRequest,
+        _createWsFrame: _createWsFrame,
+        _parseWsFrame: _parseWsFrame,
         _registerServer: _registerServer,
         _unregisterServer: _unregisterServer,
         createServer: createServer$2,
@@ -4356,802 +5171,210 @@
         }
         getWindowSize() {
             return [
-                this.columns,
-                this.rows
-            ];
-        }
-    }
-    function isatty(fd) {
-        return false;
-    }
-    var tty = {
-        ReadStream,
-        WriteStream,
-        isatty
-    };
-    var ttyShim = Object.freeze({
-        __proto__: null,
-        ReadStream: ReadStream,
-        WriteStream: WriteStream,
-        default: tty,
-        isatty: isatty
-    });
-    function hostname() {
-        return "localhost";
-    }
-    function platform() {
-        return "linux";
-    }
-    function arch() {
-        return "x64";
-    }
-    function type() {
-        return "Linux";
-    }
-    function release() {
-        return "5.10.0";
-    }
-    function version$1() {
-        return "#1 SMP";
-    }
-    function machine() {
-        return "x86_64";
-    }
-    function tmpdir() {
-        return "/tmp";
-    }
-    function homedir() {
-        return "/home/user";
-    }
-    function cpus() {
-        const cpu = {
-            model: "Virtual CPU",
-            speed: 2400,
-            times: {
-                user: 0,
-                nice: 0,
-                sys: 0,
-                idle: 0,
-                irq: 0
-            }
-        };
-        return [
-            cpu,
-            cpu
-        ];
-    }
-    function totalmem() {
-        return 4 * 1024 * 1024 * 1024;
-    }
-    function freemem() {
-        return 2 * 1024 * 1024 * 1024;
-    }
-    function uptime() {
-        return Math.floor(performance.now() / 1e3);
-    }
-    function loadavg() {
-        return [
-            0.5,
-            0.5,
-            0.5
-        ];
-    }
-    function networkInterfaces() {
-        return {
-            lo: [
-                {
-                    address: "127.0.0.1",
-                    netmask: "255.0.0.0",
-                    family: "IPv4",
-                    mac: "00:00:00:00:00:00",
-                    internal: true,
-                    cidr: "127.0.0.1/8"
-                }
-            ]
-        };
-    }
-    function userInfo() {
-        return {
-            username: "user",
-            uid: 1e3,
-            gid: 1e3,
-            shell: "/bin/bash",
-            homedir: "/home/user"
-        };
-    }
-    function endianness() {
-        return "LE";
-    }
-    function getPriority(pid) {
-        return 0;
-    }
-    function setPriority(pid, priority) {}
-    const EOL = "\n";
-    const constants$5 = {
-        signals: {
-            SIGHUP: 1,
-            SIGINT: 2,
-            SIGQUIT: 3,
-            SIGILL: 4,
-            SIGTRAP: 5,
-            SIGABRT: 6,
-            SIGBUS: 7,
-            SIGFPE: 8,
-            SIGKILL: 9,
-            SIGUSR1: 10,
-            SIGSEGV: 11,
-            SIGUSR2: 12,
-            SIGPIPE: 13,
-            SIGALRM: 14,
-            SIGTERM: 15,
-            SIGCHLD: 17,
-            SIGCONT: 18,
-            SIGSTOP: 19,
-            SIGTSTP: 20,
-            SIGTTIN: 21,
-            SIGTTOU: 22,
-            SIGURG: 23,
-            SIGXCPU: 24,
-            SIGXFSZ: 25,
-            SIGVTALRM: 26,
-            SIGPROF: 27,
-            SIGWINCH: 28,
-            SIGIO: 29,
-            SIGPWR: 30,
-            SIGSYS: 31
-        },
-        errno: {},
-        priority: {
-            PRIORITY_LOW: 19,
-            PRIORITY_BELOW_NORMAL: 10,
-            PRIORITY_NORMAL: 0,
-            PRIORITY_ABOVE_NORMAL: -7,
-            PRIORITY_HIGH: -14,
-            PRIORITY_HIGHEST: -20
-        }
-    };
-    const devNull = "/dev/null";
-    var os$1 = {
-        hostname,
-        platform,
-        arch,
-        type,
-        release,
-        version: version$1,
-        machine,
-        tmpdir,
-        homedir,
-        cpus,
-        totalmem,
-        freemem,
-        uptime,
-        loadavg,
-        networkInterfaces,
-        userInfo,
-        endianness,
-        getPriority,
-        setPriority,
-        EOL,
-        constants: constants$5,
-        devNull
-    };
-    var osShim = Object.freeze({
-        __proto__: null,
-        EOL: EOL,
-        arch: arch,
-        constants: constants$5,
-        cpus: cpus,
-        default: os$1,
-        devNull: devNull,
-        endianness: endianness,
-        freemem: freemem,
-        getPriority: getPriority,
-        homedir: homedir,
-        hostname: hostname,
-        loadavg: loadavg,
-        machine: machine,
-        networkInterfaces: networkInterfaces,
-        platform: platform,
-        release: release,
-        setPriority: setPriority,
-        tmpdir: tmpdir,
-        totalmem: totalmem,
-        type: type,
-        uptime: uptime,
-        userInfo: userInfo,
-        version: version$1
-    });
-    function randomBytes(size) {
-        const array = new Uint8Array(size);
-        crypto.getRandomValues(array);
-        return BufferPolyfill.from(array);
-    }
-    function randomUUID() {
-        return crypto.randomUUID();
-    }
-    function randomInt(min, max) {
-        if (max === void 0) {
-            max = min;
-            min = 0;
-        }
-        const range = max - min;
-        const array = new Uint32Array(1);
-        crypto.getRandomValues(array);
-        return min + array[0] % range;
-    }
-    function getRandomValues(array) {
-        return crypto.getRandomValues(array);
-    }
-    function createHash(algorithm) {
-        return new Hash(algorithm);
-    }
-    class Hash {
-        algorithm;
-        data = [];
-        constructor(algorithm){
-            this.algorithm = normalizeHashAlgorithm(algorithm);
-        }
-        update(data, encoding) {
-            let buffer;
-            if (typeof data === "string") {
-                if (encoding === "base64") {
-                    buffer = BufferPolyfill.from(atob(data));
-                } else {
-                    buffer = BufferPolyfill.from(data);
-                }
-            } else {
-                buffer = data;
-            }
-            this.data.push(buffer);
-            return this;
-        }
-        async digestAsync(encoding) {
-            const combined = concatBuffers(this.data);
-            const dataBuffer = new Uint8Array(combined).buffer;
-            const hashBuffer = await crypto.subtle.digest(this.algorithm, dataBuffer);
-            return encodeResult(new Uint8Array(hashBuffer), encoding);
-        }
-        digest(encoding) {
-            const combined = concatBuffers(this.data);
-            const hash = syncHash(combined, this.algorithm);
-            return encodeResult(hash, encoding);
-        }
-    }
-    function createHmac(algorithm, key) {
-        return new Hmac(algorithm, key);
-    }
-    class Hmac {
-        algorithm;
-        key;
-        data = [];
-        constructor(algorithm, key){
-            this.algorithm = normalizeHashAlgorithm(algorithm);
-            this.key = typeof key === "string" ? BufferPolyfill.from(key) : key;
-        }
-        update(data, encoding) {
-            const buffer = typeof data === "string" ? BufferPolyfill.from(data) : data;
-            this.data.push(buffer);
-            return this;
-        }
-        async digestAsync(encoding) {
-            const combined = concatBuffers(this.data);
-            const keyBuffer = new Uint8Array(this.key).buffer;
-            const dataBuffer = new Uint8Array(combined).buffer;
-            const cryptoKey = await crypto.subtle.importKey("raw", keyBuffer, {
-                name: "HMAC",
-                hash: this.algorithm
-            }, false, [
-                "sign"
-            ]);
-            const signature = await crypto.subtle.sign("HMAC", cryptoKey, dataBuffer);
-            return encodeResult(new Uint8Array(signature), encoding);
-        }
-        digest(encoding) {
-            const combined = concatBuffers(this.data);
-            const hash = syncHmac(combined, this.key, this.algorithm);
-            return encodeResult(hash, encoding);
-        }
-    }
-    async function pbkdf2Async(password, salt, iterations, keylen, digest) {
-        const passwordBuffer = typeof password === "string" ? BufferPolyfill.from(password) : password instanceof Uint8Array ? password : BufferPolyfill.from(password);
-        const saltBuffer = typeof salt === "string" ? BufferPolyfill.from(salt) : salt instanceof Uint8Array ? salt : BufferPolyfill.from(salt);
-        const passwordArrayBuffer = new Uint8Array(passwordBuffer).buffer;
-        const saltArrayBuffer = new Uint8Array(saltBuffer).buffer;
-        const key = await crypto.subtle.importKey("raw", passwordArrayBuffer, "PBKDF2", false, [
-            "deriveBits"
-        ]);
-        const derivedBits = await crypto.subtle.deriveBits({
-            name: "PBKDF2",
-            salt: saltArrayBuffer,
-            iterations,
-            hash: normalizeHashAlgorithm(digest)
-        }, key, keylen * 8);
-        return BufferPolyfill.from(derivedBits);
-    }
-    function pbkdf2(password, salt, iterations, keylen, digest, callback) {
-        pbkdf2Async(password, salt, iterations, keylen, digest).then((key)=>callback(null, key)).catch((err)=>callback(err, BufferPolyfill.alloc(0)));
-    }
-    function pbkdf2Sync(password, salt, iterations, keylen, digest) {
-        const passwordBuffer = typeof password === "string" ? BufferPolyfill.from(password) : password;
-        const saltBuffer = typeof salt === "string" ? BufferPolyfill.from(salt) : salt;
-        const hashAlg = normalizeHashAlgorithm(digest);
-        let hashLen;
-        if (hashAlg.includes("512")) {
-            hashLen = 64;
-        } else if (hashAlg.includes("384")) {
-            hashLen = 48;
-        } else if (hashAlg.includes("1") || hashAlg === "SHA-1") {
-            hashLen = 20;
-        } else {
-            hashLen = 32;
-        }
-        const numBlocks = Math.ceil(keylen / hashLen);
-        const derivedKey = new Uint8Array(numBlocks * hashLen);
-        for(let blockNum = 1; blockNum <= numBlocks; blockNum++){
-            const blockNumBuf = new Uint8Array(4);
-            blockNumBuf[0] = blockNum >>> 24 & 255;
-            blockNumBuf[1] = blockNum >>> 16 & 255;
-            blockNumBuf[2] = blockNum >>> 8 & 255;
-            blockNumBuf[3] = blockNum & 255;
-            const saltWithBlock = new Uint8Array(saltBuffer.length + 4);
-            saltWithBlock.set(saltBuffer);
-            saltWithBlock.set(blockNumBuf, saltBuffer.length);
-            let u = syncHmac(saltWithBlock, passwordBuffer, hashAlg);
-            const block = new Uint8Array(u);
-            for(let i = 1; i < iterations; i++){
-                u = syncHmac(u, passwordBuffer, hashAlg);
-                for(let j = 0; j < block.length; j++){
-                    block[j] ^= u[j];
-                }
-            }
-            derivedKey.set(block, (blockNum - 1) * hashLen);
-        }
-        return BufferPolyfill.from(derivedKey.slice(0, keylen));
-    }
-    function sign(algorithm, data, key, callback) {
-        const keyInfo = extractKeyInfo(key);
-        const alg = algorithm || keyInfo.algorithm;
-        if (!alg) {
-            const error = new Error("Algorithm must be specified");
-            if (callback) {
-                callback(error, null);
-                return;
-            }
-            throw error;
-        }
-        if (callback) {
-            signAsync(alg, data, keyInfo).then((sig)=>callback(null, sig)).catch((err)=>callback(err, null));
-            return;
-        }
-        const result = signSync(alg, data, keyInfo);
-        return result;
-    }
-    function verify(algorithm, data, key, signature, callback) {
-        const keyInfo = extractKeyInfo(key);
-        const alg = algorithm || keyInfo.algorithm;
-        if (!alg) {
-            const error = new Error("Algorithm must be specified");
-            if (callback) {
-                callback(error, false);
-                return;
-            }
-            throw error;
-        }
-        if (callback) {
-            verifyAsync(alg, data, keyInfo, signature).then((result)=>callback(null, result)).catch((err)=>callback(err, false));
-            return;
-        }
-        return verifySync(alg, data, keyInfo, signature);
-    }
-    function createSign(algorithm) {
-        return new Sign(algorithm);
-    }
-    function createVerify(algorithm) {
-        return new Verify(algorithm);
-    }
-    class Sign extends EventEmitter {
-        algorithm;
-        data = [];
-        constructor(algorithm){
-            super();
-            this.algorithm = algorithm;
-        }
-        update(data, encoding) {
-            const buffer = typeof data === "string" ? BufferPolyfill.from(data) : data;
-            this.data.push(buffer);
-            return this;
-        }
-        sign(privateKey, outputEncoding) {
-            const combined = concatBuffers(this.data);
-            const keyInfo = extractKeyInfo(privateKey);
-            const signature = signSync(this.algorithm, combined, keyInfo);
-            if (outputEncoding === "base64") {
-                return btoa(String.fromCharCode(...signature));
-            }
-            if (outputEncoding === "hex") {
-                return Array.from(signature).map((b)=>b.toString(16).padStart(2, "0")).join("");
-            }
-            return signature;
-        }
-    }
-    class Verify extends EventEmitter {
-        algorithm;
-        data = [];
-        constructor(algorithm){
-            super();
-            this.algorithm = algorithm;
-        }
-        update(data, encoding) {
-            const buffer = typeof data === "string" ? BufferPolyfill.from(data) : data;
-            this.data.push(buffer);
-            return this;
-        }
-        verify(publicKey, signature, signatureEncoding) {
-            const combined = concatBuffers(this.data);
-            const keyInfo = extractKeyInfo(publicKey);
-            let sig;
-            if (typeof signature === "string") {
-                if (signatureEncoding === "base64") {
-                    sig = BufferPolyfill.from(atob(signature));
-                } else if (signatureEncoding === "hex") {
-                    sig = BufferPolyfill.from(signature.match(/.{2}/g).map((byte)=>parseInt(byte, 16)));
-                } else {
-                    sig = BufferPolyfill.from(signature);
-                }
-            } else {
-                sig = signature;
-            }
-            return verifySync(this.algorithm, combined, keyInfo, sig);
-        }
-    }
-    class KeyObject {
-        _keyData;
-        _type;
-        _algorithm;
-        constructor(type, keyData, algorithm){
-            this._type = type;
-            this._keyData = keyData;
-            this._algorithm = algorithm;
-        }
-        get type() {
-            return this._type;
-        }
-        get asymmetricKeyType() {
-            if (this._type === "secret") return void 0;
-            if (this._algorithm?.includes("RSA")) return "rsa";
-            if (this._algorithm?.includes("EC") || this._algorithm?.includes("ES")) return "ec";
-            if (this._algorithm?.includes("Ed")) return "ed25519";
-            return void 0;
-        }
-        get symmetricKeySize() {
-            if (this._type !== "secret") return void 0;
-            if (this._keyData instanceof Uint8Array) {
-                return this._keyData.length * 8;
-            }
-            return void 0;
-        }
-        export(options) {
-            if (this._keyData instanceof Uint8Array) {
-                return BufferPolyfill.from(this._keyData);
-            }
-            throw new Error("Cannot export CryptoKey synchronously");
+                this.columns,
+                this.rows
+            ];
         }
     }
-    function createSecretKey(key, encoding) {
-        const keyBuffer = typeof key === "string" ? BufferPolyfill.from(key, encoding) : key;
-        return new KeyObject("secret", keyBuffer);
+    function isatty(fd) {
+        return false;
     }
-    function createPublicKey(key) {
-        const keyInfo = extractKeyInfo(key);
-        return new KeyObject("public", keyInfo.keyData, keyInfo.algorithm);
+    var tty = {
+        ReadStream,
+        WriteStream,
+        isatty
+    };
+    var ttyShim = Object.freeze({
+        __proto__: null,
+        ReadStream: ReadStream,
+        WriteStream: WriteStream,
+        default: tty,
+        isatty: isatty
+    });
+    function hostname() {
+        return "localhost";
     }
-    function createPrivateKey(key) {
-        const keyInfo = extractKeyInfo(key);
-        return new KeyObject("private", keyInfo.keyData, keyInfo.algorithm);
+    function platform() {
+        return "linux";
     }
-    function timingSafeEqual(a, b) {
-        if (a.length !== b.length) {
-            return false;
-        }
-        let result = 0;
-        for(let i = 0; i < a.length; i++){
-            result |= a[i] ^ b[i];
-        }
-        return result === 0;
+    function arch() {
+        return "x64";
     }
-    function getCiphers$1() {
-        return [
-            "aes-128-cbc",
-            "aes-256-cbc",
-            "aes-128-gcm",
-            "aes-256-gcm"
-        ];
+    function type() {
+        return "Linux";
     }
-    function getHashes() {
-        return [
-            "sha1",
-            "sha256",
-            "sha384",
-            "sha512"
-        ];
+    function release() {
+        return "5.10.0";
     }
-    const constants$4 = {
-        SSL_OP_ALL: 0,
-        RSA_PKCS1_PADDING: 1,
-        RSA_PKCS1_OAEP_PADDING: 4,
-        RSA_PKCS1_PSS_PADDING: 6
-    };
-    function normalizeHashAlgorithm(alg) {
-        const normalized = alg.toUpperCase().replace(/[^A-Z0-9]/g, "");
-        switch(normalized){
-            case "SHA1":
-                return "SHA-1";
-            case "SHA256":
-                return "SHA-256";
-            case "SHA384":
-                return "SHA-384";
-            case "SHA512":
-                return "SHA-512";
-            case "MD5":
-                return "MD5";
-            default:
-                return alg;
-        }
+    function version$1() {
+        return "#1 SMP";
     }
-    function getWebCryptoAlgorithm(nodeAlgorithm) {
-        const alg = nodeAlgorithm.toUpperCase().replace(/[^A-Z0-9]/g, "");
-        if (alg.includes("RSA")) {
-            if (alg.includes("PSS")) {
-                const hash2 = alg.match(/SHA(\d+)/)?.[0] || "SHA-256";
-                return {
-                    name: "RSA-PSS",
-                    hash: `SHA-${hash2.replace("SHA", "")}`
-                };
-            }
-            const hash = alg.match(/SHA(\d+)/)?.[0] || "SHA-256";
-            return {
-                name: "RSASSA-PKCS1-v1_5",
-                hash: `SHA-${hash.replace("SHA", "")}`
-            };
-        }
-        if (alg.startsWith("ES") || alg.includes("ECDSA")) {
-            const bits = alg.match(/\d+/)?.[0] || "256";
-            const hash = bits === "512" ? "SHA-512" : bits === "384" ? "SHA-384" : "SHA-256";
-            return {
-                name: "ECDSA",
-                hash
-            };
-        }
-        if (alg.includes("ED25519") || alg === "EDDSA") {
-            return {
-                name: "Ed25519"
-            };
-        }
-        if (alg.includes("HS") || alg.includes("HMAC")) {
-            const bits = alg.match(/\d+/)?.[0] || "256";
-            return {
-                name: "HMAC",
-                hash: `SHA-${bits}`
-            };
-        }
-        return {
-            name: "RSASSA-PKCS1-v1_5",
-            hash: "SHA-256"
-        };
+    function machine() {
+        return "x86_64";
     }
-    function extractKeyInfo(key) {
-        if (key instanceof KeyObject) {
-            return {
-                keyData: key._keyData,
-                algorithm: key._algorithm,
-                type: key._type,
-                format: "raw"
-            };
-        }
-        if (typeof key === "object" && "key" in key) {
-            return extractKeyInfo(key.key);
-        }
-        const keyStr = typeof key === "string" ? key : key.toString();
-        if (keyStr.includes("-----BEGIN")) {
-            const isPrivate = keyStr.includes("PRIVATE");
-            const isPublic = keyStr.includes("PUBLIC");
-            const base64 = keyStr.replace(/-----BEGIN [^-]+-----/, "").replace(/-----END [^-]+-----/, "").replace(/\s/g, "");
-            const keyData2 = BufferPolyfill.from(atob(base64));
-            let algorithm;
-            if (keyStr.includes("RSA")) algorithm = "RSA-SHA256";
-            else if (keyStr.includes("EC")) algorithm = "ES256";
-            else if (keyStr.includes("ED25519")) algorithm = "Ed25519";
-            return {
-                keyData: keyData2,
-                algorithm,
-                type: isPrivate ? "private" : isPublic ? "public" : "secret",
-                format: "pem"
-            };
-        }
-        const keyData = typeof key === "string" ? BufferPolyfill.from(key) : key;
-        return {
-            keyData,
-            type: "secret",
-            format: "raw"
+    function tmpdir() {
+        return "/tmp";
+    }
+    function homedir() {
+        return "/home/user";
+    }
+    function cpus() {
+        const cpu = {
+            model: "Virtual CPU",
+            speed: 2400,
+            times: {
+                user: 0,
+                nice: 0,
+                sys: 0,
+                idle: 0,
+                irq: 0
+            }
         };
+        return [
+            cpu,
+            cpu
+        ];
     }
-    function concatBuffers(buffers) {
-        const totalLength = buffers.reduce((acc, arr)=>acc + arr.length, 0);
-        const result = new Uint8Array(totalLength);
-        let offset = 0;
-        for (const buf of buffers){
-            result.set(buf, offset);
-            offset += buf.length;
-        }
-        return result;
+    function totalmem() {
+        return 4 * 1024 * 1024 * 1024;
     }
-    function encodeResult(data, encoding) {
-        if (encoding === "hex") {
-            return Array.from(data).map((b)=>b.toString(16).padStart(2, "0")).join("");
-        }
-        if (encoding === "base64") {
-            return btoa(String.fromCharCode(...data));
-        }
-        return BufferPolyfill.from(data);
+    function freemem() {
+        return 2 * 1024 * 1024 * 1024;
     }
-    function syncHash(data, algorithm) {
-        let size;
-        if (algorithm.includes("512")) {
-            size = 64;
-        } else if (algorithm.includes("384")) {
-            size = 48;
-        } else if (algorithm.includes("1") || algorithm === "SHA-1") {
-            size = 20;
-        } else {
-            size = 32;
-        }
-        const result = new Uint8Array(size);
-        let h1 = 3735928559;
-        let h2 = 1103547991;
-        for(let i = 0; i < data.length; i++){
-            h1 = Math.imul(h1 ^ data[i], 2654435761);
-            h2 = Math.imul(h2 ^ data[i], 1597334677);
-        }
-        h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
-        h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
-        for(let i = 0; i < size; i++){
-            const mix = i < size / 2 ? h1 : h2;
-            result[i] = mix >>> i % 4 * 8 & 255;
-            h1 = Math.imul(h1, 1103515245) + 12345;
-            h2 = Math.imul(h2, 1103515245) + 12345;
-        }
-        return result;
+    function uptime() {
+        return Math.floor(performance.now() / 1e3);
     }
-    function syncHmac(data, key, algorithm) {
-        const combined = new Uint8Array(key.length + data.length);
-        combined.set(key, 0);
-        combined.set(data, key.length);
-        return syncHash(combined, algorithm);
+    function loadavg() {
+        return [
+            0.5,
+            0.5,
+            0.5
+        ];
     }
-    async function signAsync(algorithm, data, keyInfo) {
-        const webCryptoAlg = getWebCryptoAlgorithm(algorithm);
-        try {
-            const cryptoKey = await importKey(keyInfo, webCryptoAlg, [
-                "sign"
-            ]);
-            const signatureAlg = webCryptoAlg.hash ? {
-                name: webCryptoAlg.name,
-                hash: webCryptoAlg.hash
-            } : {
-                name: webCryptoAlg.name
-            };
-            const dataBuffer = new Uint8Array(data).buffer;
-            const signature = await crypto.subtle.sign(signatureAlg, cryptoKey, dataBuffer);
-            return BufferPolyfill.from(signature);
-        } catch (error) {
-            console.warn("WebCrypto sign failed, using fallback:", error);
-            return signSync(algorithm, data, keyInfo);
-        }
+    function networkInterfaces() {
+        return {
+            lo: [
+                {
+                    address: "127.0.0.1",
+                    netmask: "255.0.0.0",
+                    family: "IPv4",
+                    mac: "00:00:00:00:00:00",
+                    internal: true,
+                    cidr: "127.0.0.1/8"
+                }
+            ]
+        };
     }
-    async function verifyAsync(algorithm, data, keyInfo, signature) {
-        const webCryptoAlg = getWebCryptoAlgorithm(algorithm);
-        try {
-            const cryptoKey = await importKey(keyInfo, webCryptoAlg, [
-                "verify"
-            ]);
-            const verifyAlg = webCryptoAlg.hash ? {
-                name: webCryptoAlg.name,
-                hash: webCryptoAlg.hash
-            } : {
-                name: webCryptoAlg.name
-            };
-            const sigBuffer = new Uint8Array(signature).buffer;
-            const dataBuffer = new Uint8Array(data).buffer;
-            return await crypto.subtle.verify(verifyAlg, cryptoKey, sigBuffer, dataBuffer);
-        } catch (error) {
-            console.warn("WebCrypto verify failed, using fallback:", error);
-            return verifySync(algorithm, data, keyInfo, signature);
-        }
+    function userInfo() {
+        return {
+            username: "user",
+            uid: 1e3,
+            gid: 1e3,
+            shell: "/bin/bash",
+            homedir: "/home/user"
+        };
     }
-    function signSync(algorithm, data, keyInfo) {
-        const keyData = keyInfo.keyData instanceof Uint8Array ? keyInfo.keyData : new Uint8Array(0);
-        const combined = new Uint8Array(keyData.length + data.length);
-        combined.set(keyData, 0);
-        combined.set(data, keyData.length);
-        const hash = syncHash(combined, algorithm);
-        return BufferPolyfill.from(hash);
+    function endianness() {
+        return "LE";
     }
-    function verifySync(algorithm, data, keyInfo, signature) {
-        const expectedSig = signSync(algorithm, data, keyInfo);
-        return timingSafeEqual(BufferPolyfill.from(signature), expectedSig);
+    function getPriority(pid) {
+        return 0;
     }
-    async function importKey(keyInfo, algorithm, usages) {
-        if (keyInfo.keyData instanceof CryptoKey) {
-            return keyInfo.keyData;
-        }
-        const keyData = keyInfo.keyData;
-        const keyBuffer = new Uint8Array(keyData).buffer;
-        if (keyInfo.format === "pem") {
-            const format = keyInfo.type === "private" ? "pkcs8" : "spki";
-            const importAlg = algorithm.name === "ECDSA" ? {
-                name: "ECDSA",
-                namedCurve: "P-256"
-            } : algorithm.name === "Ed25519" ? {
-                name: "Ed25519"
-            } : {
-                name: algorithm.name,
-                hash: algorithm.hash || "SHA-256"
-            };
-            return await crypto.subtle.importKey(format, keyBuffer, importAlg, true, usages);
-        }
-        if (keyInfo.type === "secret") {
-            return await crypto.subtle.importKey("raw", keyBuffer, {
-                name: algorithm.name,
-                hash: algorithm.hash
-            }, true, usages);
+    function setPriority(pid, priority) {}
+    const EOL = "\n";
+    const constants$4 = {
+        signals: {
+            SIGHUP: 1,
+            SIGINT: 2,
+            SIGQUIT: 3,
+            SIGILL: 4,
+            SIGTRAP: 5,
+            SIGABRT: 6,
+            SIGBUS: 7,
+            SIGFPE: 8,
+            SIGKILL: 9,
+            SIGUSR1: 10,
+            SIGSEGV: 11,
+            SIGUSR2: 12,
+            SIGPIPE: 13,
+            SIGALRM: 14,
+            SIGTERM: 15,
+            SIGCHLD: 17,
+            SIGCONT: 18,
+            SIGSTOP: 19,
+            SIGTSTP: 20,
+            SIGTTIN: 21,
+            SIGTTOU: 22,
+            SIGURG: 23,
+            SIGXCPU: 24,
+            SIGXFSZ: 25,
+            SIGVTALRM: 26,
+            SIGPROF: 27,
+            SIGWINCH: 28,
+            SIGIO: 29,
+            SIGPWR: 30,
+            SIGSYS: 31
+        },
+        errno: {},
+        priority: {
+            PRIORITY_LOW: 19,
+            PRIORITY_BELOW_NORMAL: 10,
+            PRIORITY_NORMAL: 0,
+            PRIORITY_ABOVE_NORMAL: -7,
+            PRIORITY_HIGH: -14,
+            PRIORITY_HIGHEST: -20
         }
-        throw new Error(`Unsupported key format: ${keyInfo.format}`);
-    }
-    var crypto$1 = {
-        randomBytes,
-        randomUUID,
-        randomInt,
-        getRandomValues,
-        createHash,
-        createHmac,
-        createSign,
-        createVerify,
-        sign,
-        verify,
-        pbkdf2,
-        pbkdf2Sync,
-        timingSafeEqual,
-        getCiphers: getCiphers$1,
-        getHashes,
+    };
+    const devNull = "/dev/null";
+    var os$1 = {
+        hostname,
+        platform,
+        arch,
+        type,
+        release,
+        version: version$1,
+        machine,
+        tmpdir,
+        homedir,
+        cpus,
+        totalmem,
+        freemem,
+        uptime,
+        loadavg,
+        networkInterfaces,
+        userInfo,
+        endianness,
+        getPriority,
+        setPriority,
+        EOL,
         constants: constants$4,
-        KeyObject,
-        createSecretKey,
-        createPublicKey,
-        createPrivateKey
+        devNull
     };
-    var cryptoShim = Object.freeze({
+    var osShim = Object.freeze({
         __proto__: null,
-        KeyObject: KeyObject,
+        EOL: EOL,
+        arch: arch,
         constants: constants$4,
-        createHash: createHash,
-        createHmac: createHmac,
-        createPrivateKey: createPrivateKey,
-        createPublicKey: createPublicKey,
-        createSecretKey: createSecretKey,
-        createSign: createSign,
-        createVerify: createVerify,
-        default: crypto$1,
-        getCiphers: getCiphers$1,
-        getHashes: getHashes,
-        getRandomValues: getRandomValues,
-        pbkdf2: pbkdf2,
-        pbkdf2Sync: pbkdf2Sync,
-        randomBytes: randomBytes,
-        randomInt: randomInt,
-        randomUUID: randomUUID,
-        sign: sign,
-        timingSafeEqual: timingSafeEqual,
-        verify: verify
+        cpus: cpus,
+        default: os$1,
+        devNull: devNull,
+        endianness: endianness,
+        freemem: freemem,
+        getPriority: getPriority,
+        homedir: homedir,
+        hostname: hostname,
+        loadavg: loadavg,
+        machine: machine,
+        networkInterfaces: networkInterfaces,
+        platform: platform,
+        release: release,
+        setPriority: setPriority,
+        tmpdir: tmpdir,
+        totalmem: totalmem,
+        type: type,
+        uptime: uptime,
+        userInfo: userInfo,
+        version: version$1
     });
     const Z_FIXED$1 = 4;
     const Z_BINARY = 0;
@@ -55868,6 +56091,7 @@ sys	0m0.000s
         return n.join(`
 `);
     }
+    const _decoder = new TextDecoder();
     class VirtualFSAdapter {
         constructor(vfs){
             this.vfs = vfs;
@@ -55879,7 +56103,7 @@ sys	0m0.000s
             }
             if (encoding === "binary" || encoding === "latin1") {
                 const buffer = this.vfs.readFileSync(path);
-                return String.fromCharCode(...buffer);
+                return uint8ToBinaryString(buffer);
             }
             return this.vfs.readFileSync(path, "utf8");
         }
@@ -55894,7 +56118,7 @@ sys	0m0.000s
             try {
                 existing = this.vfs.readFileSync(path, "utf8");
             } catch  {}
-            const newContent = typeof content === "string" ? content : new TextDecoder().decode(content);
+            const newContent = typeof content === "string" ? content : _decoder.decode(content);
             this.vfs.writeFileSync(path, existing + newContent);
         }
         async exists(path) {
@@ -56711,6 +56935,7 @@ sys	0m0.000s
         binaryType = "blob";
         _id;
         _server = null;
+        _nativeWs = null;
         onopen = null;
         onclose = null;
         onerror = null;
@@ -56731,6 +56956,10 @@ sys	0m0.000s
                 if (this.onopen) this.onopen(new Event("open"));
                 return;
             }
+            if (this.url.startsWith("ws://") || this.url.startsWith("wss://")) {
+                this._connectNative();
+                return;
+            }
             if (!messageChannel) {
                 setTimeout(()=>{
                     this.readyState = WebSocket.OPEN;
@@ -56788,10 +57017,63 @@ sys	0m0.000s
                 }
             }, 100);
         }
+        _connectNative() {
+            const NativeWS = typeof globalThis.WebSocket === "function" && globalThis.WebSocket !== WebSocket ? globalThis.WebSocket : null;
+            if (!NativeWS) {
+                setTimeout(()=>{
+                    this.readyState = WebSocket.OPEN;
+                    this.emit("open");
+                    if (this.onopen) this.onopen(new Event("open"));
+                }, 0);
+                return;
+            }
+            try {
+                this._nativeWs = new NativeWS(this.url);
+                this._nativeWs.binaryType = this.binaryType === "arraybuffer" ? "arraybuffer" : "blob";
+            } catch  {
+                this.readyState = WebSocket.CLOSED;
+                const errorEvent = new Event("error");
+                this.emit("error", errorEvent);
+                if (this.onerror) this.onerror(errorEvent);
+                return;
+            }
+            this._nativeWs.onopen = ()=>{
+                this.readyState = WebSocket.OPEN;
+                this.emit("open");
+                if (this.onopen) this.onopen(new Event("open"));
+            };
+            this._nativeWs.onmessage = (event)=>{
+                const msgEvent = new MessageEventPolyfill("message", {
+                    data: event.data
+                });
+                this.emit("message", msgEvent);
+                if (this.onmessage) this.onmessage(msgEvent);
+            };
+            this._nativeWs.onclose = (event)=>{
+                this.readyState = WebSocket.CLOSED;
+                this._nativeWs = null;
+                const closeEvent = new CloseEventPolyfill("close", {
+                    code: event.code,
+                    reason: event.reason,
+                    wasClean: event.wasClean
+                });
+                this.emit("close", closeEvent);
+                if (this.onclose) this.onclose(closeEvent);
+            };
+            this._nativeWs.onerror = ()=>{
+                const errorEvent = new Event("error");
+                this.emit("error", errorEvent);
+                if (this.onerror) this.onerror(errorEvent);
+            };
+        }
         send(data) {
             if (this.readyState !== WebSocket.OPEN) {
                 throw new Error("WebSocket is not open");
             }
+            if (this._nativeWs) {
+                this._nativeWs.send(data);
+                return;
+            }
             if (this._server) {
                 this._server._handleClientMessage(this, data);
                 return;
@@ -56810,6 +57092,10 @@ sys	0m0.000s
                 return;
             }
             this.readyState = WebSocket.CLOSING;
+            if (this._nativeWs) {
+                this._nativeWs.close(code, reason);
+                return;
+            }
             if (messageChannel) {
                 messageChannel.postMessage({
                     type: "disconnect",
@@ -56833,7 +57119,18 @@ sys	0m0.000s
         ping() {}
         pong() {}
         terminate() {
-            this.close(1006, "Connection terminated");
+            if (this._nativeWs) {
+                this._nativeWs.close();
+                this._nativeWs = null;
+            }
+            this.readyState = WebSocket.CLOSED;
+            const closeEvent = new CloseEventPolyfill("close", {
+                code: 1006,
+                reason: "Connection terminated",
+                wasClean: false
+            });
+            this.emit("close", closeEvent);
+            if (this.onclose) this.onclose(closeEvent);
         }
         _setServer(server) {
             this._server = server;
@@ -57747,7 +58044,7 @@ sys	0m0.000s
         }
         let entryPoints = options.entryPoints;
         if (entryPoints && globalVFS) {
-            const absWorkingDir = options.absWorkingDir || "/";
+            const absWorkingDir = options.absWorkingDir || (typeof globalThis !== "undefined" && globalThis.process && typeof globalThis.process.cwd === "function" ? globalThis.process.cwd() : "/");
             entryPoints = entryPoints.map((ep)=>{
                 if (ep.includes("vfs:")) {
                     const vfsIndex = ep.indexOf("vfs:");
@@ -57773,11 +58070,13 @@ sys	0m0.000s
                 return ep;
             });
         }
+        const resolvedAbsWorkingDir = options.absWorkingDir || (typeof globalThis !== "undefined" && globalThis.process && typeof globalThis.process.cwd === "function" ? globalThis.process.cwd() : "/");
         const result = await esbuildInstance.build({
             ...options,
             entryPoints,
             plugins,
-            write: false
+            write: false,
+            absWorkingDir: resolvedAbsWorkingDir
         });
         if (result.outputFiles) {
             for (const file of result.outputFiles){
@@ -59792,6 +60091,10 @@ sys	0m0.000s
                 paths: []
             };
             moduleCache[resolvedPath] = module;
+            const cacheKeys = Object.keys(moduleCache);
+            if (cacheKeys.length > 2e3) {
+                delete moduleCache[cacheKeys[0]];
+            }
             if (resolvedPath.endsWith(".json")) {
                 const content = vfs.readFileSync(resolvedPath, "utf8");
                 module.exports = JSON.parse(content);
@@ -60035,25 +60338,13 @@ ${code}
                     if (!input) return "";
                     const bytes = input instanceof ArrayBuffer ? new Uint8Array(input) : new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
                     if (this.encoding === "base64") {
-                        let binary = "";
-                        for(let i = 0; i < bytes.length; i++){
-                            binary += String.fromCharCode(bytes[i]);
-                        }
-                        return btoa(binary);
+                        return uint8ToBase64(bytes);
                     }
                     if (this.encoding === "base64url") {
-                        let binary = "";
-                        for(let i = 0; i < bytes.length; i++){
-                            binary += String.fromCharCode(bytes[i]);
-                        }
-                        return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+                        return uint8ToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
                     }
                     if (this.encoding === "hex") {
-                        let hex = "";
-                        for(let i = 0; i < bytes.length; i++){
-                            hex += bytes[i].toString(16).padStart(2, "0");
-                        }
-                        return hex;
+                        return uint8ToHex(bytes);
                     }
                     return new OriginalTextDecoder("utf-8").decode(input, options2);
                 }
@@ -60137,6 +60428,42 @@ ${code}
         getProcess() {
             return this.process;
         }
+        createREPL() {
+            const require2 = createRequire(this.vfs, this.fsShim, this.process, "/", this.moduleCache, this.options, this.processedCodeCache);
+            const consoleWrapper2 = createConsoleWrapper(this.options.onConsole);
+            const process2 = this.process;
+            const buffer = bufferModule.Buffer;
+            const GeneratorFunction = Object.getPrototypeOf(function*() {}).constructor;
+            const replGen = new GeneratorFunction("require", "console", "process", "Buffer", `var __code, __result;
+while (true) {
+  __code = yield;
+  try {
+    __result = eval(__code);
+    yield { value: __result, error: null };
+  } catch (e) {
+    yield { value: undefined, error: e };
+  }
+}`)(require2, consoleWrapper2, process2, buffer);
+            replGen.next();
+            return {
+                eval (code2) {
+                    const transformed = code2.replace(/^\s*(const|let)\s+/gm, "var ");
+                    const exprResult = replGen.next("(" + transformed + ")").value;
+                    if (!exprResult.error) {
+                        replGen.next();
+                        return exprResult.value;
+                    }
+                    replGen.next();
+                    const stmtResult = replGen.next(transformed).value;
+                    if (stmtResult.error) {
+                        replGen.next();
+                        throw stmtResult.error;
+                    }
+                    replGen.next();
+                    return stmtResult.value;
+                }
+            };
+        }
     }
     let runtime = null;
     let vfs = null;