socket-function 1.1.49 → 1.2.1

package/src/dist/webSocketServer.ts.cache

@@ -0,0 +1,365 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+exports.startSocketServer = void 0;
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const net_1 = __importDefault(require("net"));
+const callHTTPHandler_1 = require("./callHTTPHandler");
+const protocolNegotiation_1 = require("./protocolNegotiation");
+const SocketFunction_1 = require("../SocketFunction");
+const certStore_1 = require("./certStore");
+const CallFactory_1 = require("./CallFactory");
+const tlsParsing_1 = require("./tlsParsing");
+const nodeCache_1 = require("./nodeCache");
+const crypto_1 = __importDefault(require("crypto"));
+const misc_1 = require("./misc");
+const batching_1 = require("./batching");
+const logColors_1 = require("./formatting/logColors");
+const logColors_2 = require("./formatting/logColors");
+const logColors_3 = require("./formatting/logColors");
+const format_1 = require("./formatting/format");
+const forwardPort_1 = require("./forwardPort");
+async function startSocketServer(config) {
+    const ws = await Promise.resolve().then(() => __importStar(require("ws")));
+    const webSocketServer = new ws.Server({
+        noServer: true,
+        // Negotiate connection-level flags via Sec-WebSocket-Protocol. The
+        // client proposes hex-encoded values that include the target nodeId;
+        // we accept only those whose target matches OUR identity
+        // (SocketFunction.mountedNodeId — not the address the client used to
+        // reach us). If none match we return false, which rejects the
+        // handshake — exactly the semantics we want (indistinguishable from
+        // "node not reachable"). If the client sent no Sec-WebSocket-Protocol
+        // at all, this callback isn't invoked and the handshake proceeds as
+        // a legacy client.
+        handleProtocols: (protocols, request) => {
+            var _a;
+            const ourNodeId = SocketFunction_1.SocketFunction.mountedNodeId;
+            const proposed = Array.from(protocols);
+            const chosen = (0, protocolNegotiation_1.chooseProtocol)(proposed, ourNodeId, { lz4: true });
+            if (!chosen) {
+                const proposedDecoded = proposed.map(p => (0, protocolNegotiation_1.decodeProtocol)(p));
+                let target = (_a = proposedDecoded[0]) === null || _a === void 0 ? void 0 : _a.target;
+                let getMachineId = (x) => x.split(".").slice(-3).join(".");
+                if (target && getMachineId(target) === getMachineId(ourNodeId)) {
+                    console.log(`Rejecting handshake from old thread, ${target} !== ${ourNodeId}`);
+                }
+                else {
+                    console.log(`Rejecting handshake on ${ourNodeId}: none of the ${proposed.length} proposed protocols target us`, { ourNodeId, proposedDecoded });
+                }
+                return false;
+            }
+            return chosen;
+        },
+    });
+    async function setupHTTPSServer(watchOptions) {
+        let httpsServerLast;
+        let onHttpServer;
+        let httpServerPromise = new Promise(r => onHttpServer = r);
+        let lastOptions;
+        await watchOptions(value => {
+            // NOTE: If this is called a lot... STOP CALLING IT A LOT! Calling setSecureContext
+            //  so frequently likely leaks memory!
+            console.log(`Updating websocket server options`);
+            lastOptions = {
+                ...value,
+                ca: (0, certStore_1.getTrustedCertificates)(),
+                // Attempt to disable sessions, because they make SNI significantly harder to parse.
+                secureOptions: require("node:constants").SSL_OP_NO_TICKET,
+            };
+            if (!httpsServerLast) {
+                httpsServerLast = https_1.default.createServer(lastOptions);
+                // NOTE: This MIGHT be different than the keep alive option? Probably not, but also...
+                //  something weird is happening with connections...
+                httpsServerLast.keepAliveTimeout = 0;
+            }
+            else {
+                httpsServerLast.setSecureContext(lastOptions);
+            }
+            onHttpServer(httpsServerLast);
+        });
+        let httpsServer = await httpServerPromise;
+        let allowedHostnames = new Set();
+        for (let hostname of config.allowHostnames || []) {
+            allowedHostnames.add(hostname);
+        }
+        (0, certStore_1.watchTrustedCertificates)(() => {
+            // NOTE: If this is called a lot... STOP CALLING IT A LOT! Calling setSecureContext frequently leaks memory! (As in, once a minute is maybe too much, once a second is definitely too much)
+            console.log(`Updating websocket server trusted certificates`);
+            lastOptions.ca = (0, certStore_1.getTrustedCertificates)();
+            httpsServer.setSecureContext(lastOptions);
+        });
+        httpsServer.on("connection", socket => {
+            let debug = socket.remoteAddress + ":" + socket.remotePort;
+            if (!SocketFunction_1.SocketFunction.silent) {
+                console.log(`HTTP server connection established ${debug}`);
+            }
+            socket.on("error", e => {
+                if (!SocketFunction_1.SocketFunction.silent) {
+                    console.log(`HTTP server socket error for ${debug}, ${e.message}`);
+                }
+            });
+            socket.on("close", () => {
+                if (!SocketFunction_1.SocketFunction.silent) {
+                    console.log(`HTTP server socket closed for ${debug}`);
+                }
+            });
+        });
+        httpsServer.on("error", e => {
+            console.error(`Connection attempt error ${e.message}`);
+        });
+        httpsServer.on("tlsClientError", e => {
+            // NOTE: This happens a lot when we have tabs open that connected to an old
+            //  server (with old certs, that the browser will reject?)
+            if (!SocketFunction_1.SocketFunction.silent) {
+                console.error(`TLS client error ${e.message}`);
+            }
+        });
+        httpsServer.on("request", callHTTPHandler_1.httpCallHandler);
+        httpsServer.on("upgrade", (request, socket, upgradeHead) => {
+            let originHeader = request.headers["origin"];
+            if (originHeader) {
+                try {
+                    let host = (0, misc_1.getRootDomain)(new URL("ws://" + request.headers["host"]).hostname);
+                    let origin = (0, misc_1.getRootDomain)(new URL(originHeader).hostname);
+                    let allowed = host === origin || allowedHostnames.has(origin);
+                    if (!allowed && config.allowHostnameFnc) {
+                        allowed = config.allowHostnameFnc(origin);
+                    }
+                    if (!allowed) {
+                        throw new Error(`Invalid cross domain request, ${JSON.stringify(host)} !== ${JSON.stringify(origin)} (also not in config.allowedHostnames ${JSON.stringify(config.allowHostnames)})`);
+                    }
+                }
+                catch (e) {
+                    // Destroy the socket, so we don't lock up the client
+                    socket.destroy();
+                    // NOTE: Just log, because invalid requests are guaranteed to happen, and
+                    //  there's no point wasting time looking at them.
+                    console.log(e);
+                    return;
+                }
+            }
+            webSocketServer.handleUpgrade(request, socket, upgradeHead, (ws) => {
+                const { nodeId, localNodeId } = (0, callHTTPHandler_1.getNodeIdsFromRequest)(request);
+                (0, CallFactory_1.createCallFactory)(ws, nodeId, localNodeId).catch(e => {
+                    console.error(`Error in creating call factory, ${e.stack}`);
+                });
+            });
+        });
+        return httpsServer;
+    }
+    // TODO: Only allow unauthorized for ip certificates, and then for domains use the domain as the nodeId,
+    //  so it is easy to read, and consistent.
+    let options = {
+        ...config,
+        // Keep alive causes problems with our HTTP requests. AND... almost all of our data uses
+        //  our websockets, so... we really don't need to keep alive our HTTP requests
+        //  (and our images go through cloudflare, so we don't even need keep alive for that)
+        keepAlive: false,
+        keepAliveInitialDelay: 0,
+        noDelay: true,
+    };
+    if (!config.cert) {
+        throw new Error("No cert specified");
+    }
+    if (!config.key) {
+        throw new Error("No key specified");
+    }
+    const mainHTTPSServer = await setupHTTPSServer(callback => callback(options));
+    let sniServers = new Map();
+    for (let [domain, obj] of Object.entries(config.SNICerts || {})) {
+        sniServers.set(domain, await setupHTTPSServer(obj));
+    }
+    let httpServer = http_1.default.createServer({ keepAlive: false, }, async function (req, res) {
+        let url = new URL("http://" + req.headers.host + req.url);
+        url.protocol = "https:";
+        //url.hostname = opts.hostname;
+        url.hostname = req.headers.host || "";
+        res.writeHead(301, { Location: url + "" });
+        res.end();
+    });
+    httpServer.keepAliveTimeout = 0;
+    httpServer.on("error", e => {
+        console.error(`HTTP error ${e.stack}`);
+    });
+    let realServer = net_1.default.createServer(socket => {
+        const debug = socket.remoteAddress + ":" + socket.remotePort;
+        if (!SocketFunction_1.SocketFunction.silent) {
+            console.log(`Received TCP connection from ${debug}`);
+        }
+        function handleTLSHello(buffer, packetCount) {
+            if (!SocketFunction_1.SocketFunction.silent) {
+                console.log(`Received TCP header packet from ${debug}, have ${buffer.length} bytes so far, ${packetCount} packets`);
+            }
+            // All HTTPS requests start with 22, and no HTTP requests start with 22,
+            //  so we just need to read the first byte.
+            let server;
+            if (buffer[0] !== 22) {
+                server = httpServer;
+            }
+            else {
+                let data = (0, tlsParsing_1.parseTLSHello)(buffer);
+                if (data.missingBytes > 0) {
+                    return "more";
+                }
+                let sni = data.extensions.filter(x => x.type === tlsParsing_1.SNIType).flatMap(x => (0, tlsParsing_1.parseSNIExtension)(x.data))[0];
+                if (!SocketFunction_1.SocketFunction.silent) {
+                    console.log(`Received TCP connection with SNI ${JSON.stringify(sni)}. Have handlers for: ${Array.from(sniServers.keys()).join(", ")}`);
+                }
+                if (!sni) {
+                    console.warn(`No SNI found in TLS hello from ${debug}, using main server. Packets ${packetCount}`);
+                    console.log(buffer.toString("base64"));
+                }
+                let originalSNI = sni;
+                if (sni) {
+                    // Remove subdomains until we can find a domain
+                    while (!sniServers.has(sni)) {
+                        let parts = sni.split(".");
+                        if (parts.length <= 2)
+                            break;
+                        sni = parts.slice(1).join(".");
+                    }
+                }
+                if (!sniServers.has(sni)) {
+                    console.warn(`No SNI server found for ${originalSNI}, using main server. SNI candidates ${Array.from(sniServers.keys()).join(", ")}`);
+                }
+                server = sniServers.get(sni) || mainHTTPSServer;
+            }
+            // NOTE: Messages aren't dequeued until the current handler finishes, so we don't need to pause the socket or anything.
+            server.emit("connection", socket);
+            socket.unshift(buffer);
+        }
+        let buffers = [];
+        function getNextData() {
+            // NOTE: ONCE is used, so we only look at the first buffer, and then after that
+            //  we pipe. This should be very efficient, as pipe has insane throughput
+            //  (100s of MB/s, easily, even on a terrible machine).
+            socket.once("data", buffer => {
+                if (typeof buffer === "string") {
+                    buffer = Buffer.from(buffer);
+                }
+                buffers.push(buffer);
+                let result = handleTLSHello(Buffer.concat(buffers), buffers.length);
+                if (result === "more") {
+                    getNextData();
+                }
+            });
+        }
+        getNextData();
+        socket.on("error", (e) => {
+            console.error(`TCP socket error for ${debug}, ${e.stack}`);
+        });
+        socket.on("close", () => {
+            if (!SocketFunction_1.SocketFunction.silent) {
+                console.log(`TCP socket closed for ${debug}`);
+            }
+        });
+    });
+    let host = config.public ? "0.0.0.0" : "127.0.0.1";
+    if (config.ip) {
+        host = config.ip;
+    }
+    let port = config.port;
+    if (!SocketFunction_1.SocketFunction.silent) {
+        console.log((0, logColors_2.yellow)(`Trying to listening on ${host}:${port}`));
+    }
+    let listeningPromise = waitUntilListening();
+    listeningPromise.catch(e => { });
+    // Return true if we are listening, false if the address is in use, and throws on other errors
+    async function waitUntilListening() {
+        return await new Promise((resolve, reject) => {
+            realServer.once("error", e => {
+                reject(e);
+            });
+            realServer.once("listening", () => {
+                resolve(false);
+            });
+        });
+    }
+    if (config.useAvailablePortIfPortInUse && port) {
+        realServer.listen(port, host);
+        let isListening = await new Promise((resolve, reject) => {
+            if (realServer.listening) {
+                resolve(true);
+                return;
+            }
+            realServer.once("error", e => {
+                if (e.message.includes("EADDRINUSE")) {
+                    resolve(true);
+                }
+                else {
+                    reject(e);
+                }
+            });
+            realServer.once("listening", () => {
+                resolve(false);
+            });
+        });
+        if (!isListening) {
+            port = 0;
+            realServer.listen(port, host);
+            listeningPromise = waitUntilListening();
+        }
+    }
+    else {
+        realServer.listen(port, host);
+    }
+    await listeningPromise;
+    port = realServer.address().port;
+    if (config.autoForwardPort && config.public) {
+        // let externalIP = await getExternalIP();
+        // let isListening = await testTCPIsListening(externalIP, port);
+        // if (!isListening) {
+        //     console.log(magenta(`Port ${port} is not externally reachable, trying to forward it`));
+        //     await forwardPort({ externalPort: port, internalPort: port });
+        // }
+        // Even if they are listening, they might not stay listening. Forward every 8 hours
+        //      (including at the start, in case the forward is about to expire).
+        async function forward() {
+            await (0, forwardPort_1.forwardPort)({ externalPort: port, internalPort: port });
+            console.log((0, logColors_1.magenta)(`Forwarded port ${port} to our machine`));
+        }
+        // Every hour, in case our network configuration changes
+        (0, batching_1.runInfinitePollCallAtStart)(misc_1.timeInMinute * 30, forward).catch(e => console.error((0, logColors_1.red)(`Error in port forwarding ${e.stack}`)));
+    }
+    let nodeId = (0, nodeCache_1.getNodeId)(getCommonName(config.cert), port);
+    console.log((0, logColors_3.green)(`Started Listening on ${nodeId} (${host}) after ${(0, format_1.formatTime)(process.uptime() * 1000)}`));
+    return nodeId;
+}
+exports.startSocketServer = startSocketServer;
+function getCommonName(cert) {
+    let subject = new crypto_1.default.X509Certificate(cert).subject;
+    let subjectKVPs = new Map(subject.split(",").map(x => x.trim().split("=")).map(x => [x[0], x.slice(1).join("=")]));
+    let commonName = subjectKVPs.get("CN");
+    if (!commonName)
+        throw new Error(`No common name in subject: ${subject}`);
+    return commonName;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webSocketServer.js","sourceRoot":"","sources":["webSocketServer.ts"],"names":[],"mappings":"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","sourcesContent":["import https from \"https\";\nimport http from \"http\";\nimport net from \"net\";\nimport tls from \"tls\";\nimport { getNodeIdsFromRequest, httpCallHandler } from \"./callHTTPHandler\";\nimport { chooseProtocol, decodeProtocol } from \"./protocolNegotiation\";\nimport { SocketFunction } from \"../SocketFunction\";\nimport { getTrustedCertificates, watchTrustedCertificates } from \"./certStore\";\nimport { createCallFactory } from \"./CallFactory\";\nimport { parseSNIExtension, parseTLSHello, SNIType } from \"./tlsParsing\";\nimport debugbreak from \"debugbreak\";\nimport { getNodeId } from \"./nodeCache\";\nimport crypto from \"crypto\";\nimport { Watchable, getRootDomain, timeInHour, timeInMinute } from \"./misc\";\nimport { delay, runInfinitePoll, runInfinitePollCallAtStart } from \"./batching\";\nimport { magenta, red } from \"./formatting/logColors\";\nimport { yellow } from \"./formatting/logColors\";\nimport { green } from \"./formatting/logColors\";\nimport { formatTime } from \"./formatting/format\";\nimport { getExternalIP, testTCPIsListening } from \"./networking\";\nimport { forwardPort } from \"./forwardPort\";\n\nexport type SocketServerConfig = (\n    https.ServerOptions & {\n        key: string | Buffer;\n        cert: string | Buffer;\n\n        port: number;\n        /** You can also set `port: 0` if you don't care what port you want at all.  */\n        useAvailablePortIfPortInUse?: boolean;\n\n        // public sets ip to \"0.0.0.0\", otherwise it defaults to \"127.0.0.1\", which\n        //  causes the server to only accept local connections.\n        public?: boolean;\n        /** Tries forwarding ports (using UPnP), if we detect they aren't externally reachable.\n         *      - This causes an extra request and delay during startup, so should only be used\n         *          during development.\n         *      - Ignored if public is false (in which case we mount on 127.0.0.1, so port forwarding\n         *          wouldn't matter anyways).\n        */\n        autoForwardPort?: boolean;\n        ip?: string;\n\n        // NOTE: Any same origin accesses are allowed (header.origin === header.host)\n        // For example, to allow \"letx.ca\" to access the server (when the hosted domain\n        //  may be, \"querysub.com\", for example), use [\"letx.ca\"]\n        allowHostnames?: string[];\n        // If a hostname is in allowHostnames or allowHostnameFnc returns true, it is allowed\n        allowHostnameFnc?: (hostname: string) => boolean;\n\n        /** If the SNI matches this domain, we use a different key/cert.\n         *      We remove subdomains until we find a match\n         */\n        SNICerts?: {\n            [domain: string]: Watchable<https.ServerOptions>;\n        };\n    }\n);\n\nexport async function startSocketServer(\n    config: SocketServerConfig\n): Promise<string> {\n    const ws = await import(\"ws\");\n\n    const webSocketServer = new ws.Server({\n        noServer: true,\n        // Negotiate connection-level flags via Sec-WebSocket-Protocol. The\n        // client proposes hex-encoded values that include the target nodeId;\n        // we accept only those whose target matches OUR identity\n        // (SocketFunction.mountedNodeId — not the address the client used to\n        // reach us). If none match we return false, which rejects the\n        // handshake — exactly the semantics we want (indistinguishable from\n        // \"node not reachable\"). If the client sent no Sec-WebSocket-Protocol\n        // at all, this callback isn't invoked and the handshake proceeds as\n        // a legacy client.\n        handleProtocols: (protocols, request) => {\n            const ourNodeId = SocketFunction.mountedNodeId;\n            const proposed = Array.from(protocols);\n            const chosen = chooseProtocol(proposed, ourNodeId, { lz4: true });\n            if (!chosen) {\n                const proposedDecoded = proposed.map(p => decodeProtocol(p));\n                let target = proposedDecoded[0]?.target;\n                let getMachineId = (x: string) => x.split(\".\").slice(-3).join(\".\");\n                if (target && getMachineId(target) === getMachineId(ourNodeId)) {\n                    console.log(`Rejecting handshake from old thread, ${target} !== ${ourNodeId}`);\n                } else {\n                    console.log(`Rejecting handshake on ${ourNodeId}: none of the ${proposed.length} proposed protocols target us`, { ourNodeId, proposedDecoded });\n                }\n                return false;\n            }\n            return chosen;\n        },\n    });\n\n    async function setupHTTPSServer(watchOptions: Watchable<https.ServerOptions>) {\n        let httpsServerLast: https.Server | undefined;\n        let onHttpServer: (server: https.Server) => void;\n        let httpServerPromise = new Promise<https.Server>(r => onHttpServer = r);\n        let lastOptions!: https.ServerOptions;\n        await watchOptions(value => {\n            // NOTE: If this is called a lot... STOP CALLING IT A LOT! Calling setSecureContext\n            //  so frequently likely leaks memory!\n            console.log(`Updating websocket server options`);\n            lastOptions = {\n                ...value,\n                ca: getTrustedCertificates(),\n                // Attempt to disable sessions, because they make SNI significantly harder to parse.\n                secureOptions: require(\"node:constants\").SSL_OP_NO_TICKET,\n            };\n            if (!httpsServerLast) {\n                httpsServerLast = https.createServer(lastOptions);\n                // NOTE: This MIGHT be different than the keep alive option? Probably not, but also...\n                //  something weird is happening with connections...\n                httpsServerLast.keepAliveTimeout = 0;\n            } else {\n                httpsServerLast.setSecureContext(lastOptions);\n            }\n            onHttpServer(httpsServerLast);\n        });\n        let httpsServer = await httpServerPromise;\n\n        let allowedHostnames = new Set<string>();\n        for (let hostname of config.allowHostnames || []) {\n            allowedHostnames.add(hostname);\n        }\n\n        watchTrustedCertificates(() => {\n            // NOTE: If this is called a lot... STOP CALLING IT A LOT! Calling setSecureContext frequently leaks memory! (As in, once a minute is maybe too much, once a second is definitely too much)\n            console.log(`Updating websocket server trusted certificates`);\n            lastOptions.ca = getTrustedCertificates();\n            httpsServer.setSecureContext(lastOptions);\n        });\n\n        httpsServer.on(\"connection\", socket => {\n            let debug = (socket as any).remoteAddress + \":\" + (socket as any).remotePort;\n            if (!SocketFunction.silent) {\n                console.log(`HTTP server connection established ${debug}`);\n            }\n            socket.on(\"error\", e => {\n                if (!SocketFunction.silent) {\n                    console.log(`HTTP server socket error for ${debug}, ${e.message}`);\n                }\n            });\n            socket.on(\"close\", () => {\n                if (!SocketFunction.silent) {\n                    console.log(`HTTP server socket closed for ${debug}`);\n                }\n            });\n        });\n        httpsServer.on(\"error\", e => {\n            console.error(`Connection attempt error ${e.message}`);\n        });\n        httpsServer.on(\"tlsClientError\", e => {\n            // NOTE: This happens a lot when we have tabs open that connected to an old\n            //  server (with old certs, that the browser will reject?)\n            if (!SocketFunction.silent) {\n                console.error(`TLS client error ${e.message}`);\n            }\n        });\n\n        httpsServer.on(\"request\", httpCallHandler);\n\n        httpsServer.on(\"upgrade\", (request, socket, upgradeHead) => {\n            let originHeader = request.headers[\"origin\"];\n            if (originHeader) {\n                try {\n                    let host = getRootDomain(new URL(\"ws://\" + request.headers[\"host\"]).hostname);\n                    let origin = getRootDomain(new URL(originHeader).hostname);\n                    let allowed = host === origin || allowedHostnames.has(origin);\n                    if (!allowed && config.allowHostnameFnc) {\n                        allowed = config.allowHostnameFnc(origin);\n                    }\n                    if (!allowed) {\n                        throw new Error(`Invalid cross domain request, ${JSON.stringify(host)} !== ${JSON.stringify(origin)} (also not in config.allowedHostnames ${JSON.stringify(config.allowHostnames)})`);\n                    }\n                } catch (e) {\n                    // Destroy the socket, so we don't lock up the client\n                    socket.destroy();\n                    // NOTE: Just log, because invalid requests are guaranteed to happen, and\n                    //  there's no point wasting time looking at them.\n                    console.log(e);\n                    return;\n                }\n            }\n            webSocketServer.handleUpgrade(request, socket, upgradeHead, (ws) => {\n                const { nodeId, localNodeId } = getNodeIdsFromRequest(request);\n                createCallFactory(ws, nodeId, localNodeId).catch(e => {\n                    console.error(`Error in creating call factory, ${e.stack}`);\n                });\n            });\n        });\n        return httpsServer;\n    }\n\n    // TODO: Only allow unauthorized for ip certificates, and then for domains use the domain as the nodeId,\n    //  so it is easy to read, and consistent.\n    let options: https.ServerOptions = {\n        ...config,\n        // Keep alive causes problems with our HTTP requests. AND... almost all of our data uses\n        //  our websockets, so... we really don't need to keep alive our HTTP requests\n        //  (and our images go through cloudflare, so we don't even need keep alive for that)\n        keepAlive: false,\n        keepAliveInitialDelay: 0,\n        noDelay: true,\n    };\n    if (!config.cert) {\n        throw new Error(\"No cert specified\");\n    }\n    if (!config.key) {\n        throw new Error(\"No key specified\");\n    }\n\n    const mainHTTPSServer = await setupHTTPSServer(callback => callback(options));\n    let sniServers = new Map<string, https.Server>();\n    for (let [domain, obj] of Object.entries(config.SNICerts || {})) {\n        sniServers.set(domain, await setupHTTPSServer(obj));\n    }\n\n    let httpServer = http.createServer({ keepAlive: false, }, async function (req, res) {\n        let url = new URL(\"http://\" + req.headers.host + req.url);\n        url.protocol = \"https:\";\n        //url.hostname = opts.hostname;\n        url.hostname = req.headers.host || \"\";\n        res.writeHead(301, { Location: url + \"\" });\n        res.end();\n    });\n    httpServer.keepAliveTimeout = 0;\n    httpServer.on(\"error\", e => {\n        console.error(`HTTP error ${e.stack}`);\n    });\n\n    let realServer = net.createServer(socket => {\n        const debug = socket.remoteAddress + \":\" + socket.remotePort;\n        if (!SocketFunction.silent) {\n            console.log(`Received TCP connection from ${debug}`);\n        }\n        function handleTLSHello(buffer: Buffer, packetCount: number): void | \"more\" {\n            if (!SocketFunction.silent) {\n                console.log(`Received TCP header packet from ${debug}, have ${buffer.length} bytes so far, ${packetCount} packets`);\n            }\n            // All HTTPS requests start with 22, and no HTTP requests start with 22,\n            //  so we just need to read the first byte.\n            let server: https.Server | http.Server;\n            if (buffer[0] !== 22) {\n                server = httpServer;\n            } else {\n                let data = parseTLSHello(buffer);\n                if (data.missingBytes > 0) {\n                    return \"more\";\n                }\n                let sni = data.extensions.filter(x => x.type === SNIType).flatMap(x => parseSNIExtension(x.data))[0];\n                if (!SocketFunction.silent) {\n                    console.log(`Received TCP connection with SNI ${JSON.stringify(sni)}. Have handlers for: ${Array.from(sniServers.keys()).join(\", \")}`);\n                }\n                if (!sni) {\n                    console.warn(`No SNI found in TLS hello from ${debug}, using main server. Packets ${packetCount}`);\n                    console.log(buffer.toString(\"base64\"));\n                }\n                let originalSNI = sni;\n                if (sni) {\n                    // Remove subdomains until we can find a domain\n                    while (!sniServers.has(sni)) {\n                        let parts = sni.split(\".\");\n                        if (parts.length <= 2) break;\n                        sni = parts.slice(1).join(\".\");\n                    }\n                }\n\n                if (!sniServers.has(sni)) {\n                    console.warn(`No SNI server found for ${originalSNI}, using main server. SNI candidates ${Array.from(sniServers.keys()).join(\", \")}`);\n                }\n                server = sniServers.get(sni) || mainHTTPSServer;\n            }\n\n            // NOTE: Messages aren't dequeued until the current handler finishes, so we don't need to pause the socket or anything.\n            server.emit(\"connection\", socket);\n            socket.unshift(buffer);\n        }\n        let buffers: Buffer[] = [];\n        function getNextData() {\n            // NOTE: ONCE is used, so we only look at the first buffer, and then after that\n            //  we pipe. This should be very efficient, as pipe has insane throughput\n            //  (100s of MB/s, easily, even on a terrible machine).\n            socket.once(\"data\", buffer => {\n                if (typeof buffer === \"string\") {\n                    buffer = Buffer.from(buffer);\n                }\n                buffers.push(buffer);\n                let result = handleTLSHello(Buffer.concat(buffers), buffers.length);\n                if (result === \"more\") {\n                    getNextData();\n                }\n            });\n        }\n        getNextData();\n        socket.on(\"error\", (e) => {\n            console.error(`TCP socket error for ${debug}, ${e.stack}`);\n        });\n        socket.on(\"close\", () => {\n            if (!SocketFunction.silent) {\n                console.log(`TCP socket closed for ${debug}`);\n            }\n        });\n    });\n\n\n    let host = config.public ? \"0.0.0.0\" : \"127.0.0.1\";\n    if (config.ip) {\n        host = config.ip;\n    }\n\n    let port = config.port;\n    if (!SocketFunction.silent) {\n        console.log(yellow(`Trying to listening on ${host}:${port}`));\n    }\n\n    let listeningPromise = waitUntilListening();\n    listeningPromise.catch(e => { });\n\n    // Return true if we are listening, false if the address is in use, and throws on other errors\n    async function waitUntilListening() {\n        return await new Promise<boolean>((resolve, reject) => {\n            realServer.once(\"error\", e => {\n                reject(e);\n            });\n            realServer.once(\"listening\", () => {\n                resolve(false);\n            });\n        });\n    }\n\n    if (config.useAvailablePortIfPortInUse && port) {\n        realServer.listen(port, host);\n        let isListening = await new Promise<boolean>((resolve, reject) => {\n            if (realServer.listening) {\n                resolve(true);\n                return;\n            }\n            realServer.once(\"error\", e => {\n                if (e.message.includes(\"EADDRINUSE\")) {\n                    resolve(true);\n                } else {\n                    reject(e);\n                }\n            });\n            realServer.once(\"listening\", () => {\n                resolve(false);\n            });\n        });\n        if (!isListening) {\n            port = 0;\n            realServer.listen(port, host);\n            listeningPromise = waitUntilListening();\n        }\n    } else {\n        realServer.listen(port, host);\n    }\n\n    await listeningPromise;\n    port = (realServer.address() as net.AddressInfo).port;\n\n    if (config.autoForwardPort && config.public) {\n        // let externalIP = await getExternalIP();\n        // let isListening = await testTCPIsListening(externalIP, port);\n        // if (!isListening) {\n        //     console.log(magenta(`Port ${port} is not externally reachable, trying to forward it`));\n        //     await forwardPort({ externalPort: port, internalPort: port });\n        // }\n        // Even if they are listening, they might not stay listening. Forward every 8 hours\n        //      (including at the start, in case the forward is about to expire).\n        async function forward() {\n            await forwardPort({ externalPort: port, internalPort: port });\n            console.log(magenta(`Forwarded port ${port} to our machine`));\n        }\n        // Every hour, in case our network configuration changes\n        runInfinitePollCallAtStart(timeInMinute * 30, forward).catch(e => console.error(red(`Error in port forwarding ${e.stack}`)));\n    }\n\n    let nodeId = getNodeId(getCommonName(config.cert), port);\n    console.log(green(`Started Listening on ${nodeId} (${host}) after ${formatTime(process.uptime() * 1000)}`));\n\n    return nodeId;\n}\n\nfunction getCommonName(cert: Buffer | string) {\n    let subject = new crypto.X509Certificate(cert).subject;\n    let subjectKVPs = new Map(subject.split(\",\").map(x => x.trim().split(\"=\")).map(x => [x[0], x.slice(1).join(\"=\")]));\n    let commonName = subjectKVPs.get(\"CN\");\n    if (!commonName) throw new Error(`No common name in subject: ${subject}`);\n    return commonName;\n}\n"]}
+ /* _JS_SOURCE_HASH = "85f78c2705c67c438736081567eb3903aa85954b6fdbf4bdce70f677349077ab"; */

package/src/dist/websocketFactory.ts.cache

@@ -0,0 +1,53 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.createWebsocketFactory = exports.getTLSSocket = void 0;
+const misc_1 = require("./misc");
+const certStore_1 = require("./certStore");
+const nodeCache_1 = require("./nodeCache");
+const SocketFunction_1 = require("../SocketFunction");
+function getTLSSocket(webSocket) {
+    return webSocket._socket;
+}
+exports.getTLSSocket = getTLSSocket;
+/** NOTE: We create a factory, which embeds the key/cert information. Otherwise retries might use
+ *      a different key/cert context.
+ */
+function createWebsocketFactory() {
+    if (!(0, misc_1.isNode)()) {
+        return (nodeId, proposedProtocols) => {
+            let location = (0, nodeCache_1.getNodeIdLocation)(nodeId);
+            if (!location)
+                throw new Error(`Cannot connect to ${nodeId}, no address known`);
+            let { address, port } = location;
+            if (!SocketFunction_1.SocketFunction.silent) {
+                console.log(`Connecting to ${address}:${port}`);
+            }
+            if (proposedProtocols && proposedProtocols.length > 0) {
+                return new WebSocket(`wss://${address}:${port}`, proposedProtocols);
+            }
+            return new WebSocket(`wss://${address}:${port}`);
+        };
+    }
+    else {
+        return (nodeId, proposedProtocols) => {
+            let location = (0, nodeCache_1.getNodeIdLocation)(nodeId);
+            if (!location)
+                throw new Error(`Cannot connect to ${nodeId}, no address known`);
+            let { address, port } = location;
+            if (!SocketFunction_1.SocketFunction.silent) {
+                console.log(`Connecting to ${address}:${port}`);
+            }
+            const ws = require("ws");
+            let webSocket = new ws.WebSocket(`wss://${address}:${port}`, proposedProtocols, {
+                ca: (0, certStore_1.getTrustedCertificates)(),
+            });
+            // NOTE: Little setup is done here, because Sometimes websockets are created here,
+            //      and sometimes via incoming connections, We should do most setup in
+            //      CallFactory.ts:initializeWebsocket
+            return webSocket;
+        };
+    }
+}
+exports.createWebsocketFactory = createWebsocketFactory;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "cc6c144726cbe9b77a75d3be5d5b44d840387337e85b8dceb579d4a4efc7e33d"; */

package/src/formatting/dist/colors.ts.cache

@@ -0,0 +1,98 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.hslSetSaturate = exports.hslAddSaturate = exports.hslDarkenLinear = exports.hslDarkenGamma = exports.hslLightenLinear = exports.hslLightenGamma = exports.hslToHex = exports.hslToRGB = exports.hslText = void 0;
+function hslText(color) {
+    return `hsl(${color.h}, ${color.s}%, ${color.l}%)`;
+}
+exports.hslText = hslText;
+function hslToRGB(color) {
+    let { h, s, l } = color;
+    h /= 360;
+    s /= 100;
+    l /= 100;
+    let r, g, b;
+    if (s === 0) {
+        r = g = b = l; // achromatic
+    }
+    else {
+        const hue2rgb = (p, q, t) => {
+            if (t < 0)
+                t += 1;
+            if (t > 1)
+                t -= 1;
+            if (t < 1 / 6)
+                return p + (q - p) * 6 * t;
+            if (t < 1 / 2)
+                return q;
+            if (t < 2 / 3)
+                return p + (q - p) * (2 / 3 - t) * 6;
+            return p;
+        };
+        const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        const p = 2 * l - q;
+        r = hue2rgb(p, q, h + 1 / 3);
+        g = hue2rgb(p, q, h);
+        b = hue2rgb(p, q, h - 1 / 3);
+        if (b < 0) {
+            b = 0;
+        }
+    }
+    return { r: Math.floor(r * 255), g: Math.floor(g * 255), b: Math.floor(b * 255) };
+}
+exports.hslToRGB = hslToRGB;
+function hslToHex(color) {
+    let { r, g, b } = hslToRGB(color);
+    const toHex = (x) => {
+        const hex = x.toString(16);
+        return hex.length === 1 ? "0" + hex : hex;
+    };
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+exports.hslToHex = hslToHex;
+// Consider 
+function hslLightenGamma(hsl, fraction) {
+    let l = ((hsl.l ** 2) * (1 + fraction)) ** 0.5;
+    if (l > 255)
+        l = 255;
+    if (!l || l < 0)
+        l = 0;
+    return { h: hsl.h, s: hsl.s, l };
+}
+exports.hslLightenGamma = hslLightenGamma;
+function hslLightenLinear(hsl, lightness) {
+    let l = hsl.l + lightness;
+    if (l > 255)
+        l = 255;
+    if (!l || l < 0)
+        l = 0;
+    return { h: hsl.h, s: hsl.s, l };
+}
+exports.hslLightenLinear = hslLightenLinear;
+function hslDarkenGamma(hsl, fraction) {
+    return hslLightenGamma(hsl, -fraction);
+}
+exports.hslDarkenGamma = hslDarkenGamma;
+function hslDarkenLinear(hsl, lightness) {
+    return hslLightenLinear(hsl, -lightness);
+}
+exports.hslDarkenLinear = hslDarkenLinear;
+function hslAddSaturate(hsl, saturation) {
+    // If something has ZERO saturation, the color is meaningless, so increasing the saturation
+    //  will likely not give the desired impact. Instead, darken the grey, which should give the desire effect.
+    if (hsl.s === 0) {
+        return hslDarkenGamma(hsl, 0.2);
+    }
+    return { h: hsl.h, s: hsl.s + saturation, l: hsl.l };
+}
+exports.hslAddSaturate = hslAddSaturate;
+function hslSetSaturate(hsl, saturation) {
+    // If something has ZERO saturation, the color is meaningless, so increasing the saturation
+    //  will likely not give the desired impact. Instead, set the lightness.
+    if (hsl.s === 0) {
+        return { h: hsl.h, s: hsl.s, l: 100 - saturation };
+    }
+    return { h: hsl.h, s: saturation, l: hsl.l };
+}
+exports.hslSetSaturate = hslSetSaturate;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"colors.js","sourceRoot":"","sources":["colors.ts"],"names":[],"mappings":";;;AACA,SAAgB,OAAO,CAAC,KAAU;IAC9B,OAAO,OAAO,KAAK,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC;AACvD,CAAC;AAFD,0BAEC;AAED,SAAgB,QAAQ,CAAC,KAAU;IAC/B,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,KAAK,CAAC;IACxB,CAAC,IAAI,GAAG,CAAC;IACT,CAAC,IAAI,GAAG,CAAC;IACT,CAAC,IAAI,GAAG,CAAC;IACT,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IACZ,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACV,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa;IAChC,CAAC;SAAM,CAAC;QACJ,MAAM,OAAO,GAAG,CAAC,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,EAAE;YAChD,IAAI,CAAC,GAAG,CAAC;gBAAE,CAAC,IAAI,CAAC,CAAC;YAClB,IAAI,CAAC,GAAG,CAAC;gBAAE,CAAC,IAAI,CAAC,CAAC;YAClB,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC1C,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,OAAO,CAAC,CAAC;YACxB,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;YACpD,OAAO,CAAC,CAAC;QACb,CAAC,CAAC;QACF,MAAM,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChD,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpB,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QAC7B,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACrB,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QAC7B,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACR,CAAC,GAAG,CAAC,CAAC;QACV,CAAC;IACL,CAAC;IACD,OAAO,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC;AACtF,CAAC;AA3BD,4BA2BC;AAED,SAAgB,QAAQ,CAAC,KAAU;IAC/B,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAClC,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,EAAE;QACxB,MAAM,GAAG,GAAG,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAC3B,OAAO,GAAG,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;IAC9C,CAAC,CAAC;IACF,OAAO,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AAChD,CAAC;AAPD,4BAOC;AAED,YAAY;AACZ,SAAgB,eAAe,CAAC,GAAQ,EAAE,QAAgB;IACtD,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,IAAI,GAAG,CAAC;IAC/C,IAAI,CAAC,GAAG,GAAG;QAAE,CAAC,GAAG,GAAG,CAAC;IACrB,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,CAAC,GAAG,CAAC,CAAC;IACvB,OAAO,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;AACrC,CAAC;AALD,0CAKC;AACD,SAAgB,gBAAgB,CAAC,GAAQ,EAAE,SAAiB;IACxD,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC;IAC1B,IAAI,CAAC,GAAG,GAAG;QAAE,CAAC,GAAG,GAAG,CAAC;IACrB,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;QAAE,CAAC,GAAG,CAAC,CAAC;IACvB,OAAO,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;AACrC,CAAC;AALD,4CAKC;AACD,SAAgB,cAAc,CAAC,GAAQ,EAAE,QAAgB;IACrD,OAAO,eAAe,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAC;AAC3C,CAAC;AAFD,wCAEC;AACD,SAAgB,eAAe,CAAC,GAAQ,EAAE,SAAiB;IACvD,OAAO,gBAAgB,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;AAC7C,CAAC;AAFD,0CAEC;AAED,SAAgB,cAAc,CAAC,GAAQ,EAAE,UAAkB;IACvD,2FAA2F;IAC3F,2GAA2G;IAC3G,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;QACd,OAAO,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,UAAU,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC;AACzD,CAAC;AAPD,wCAOC;AACD,SAAgB,cAAc,CAAC,GAAQ,EAAE,UAAkB;IACvD,2FAA2F;IAC3F,wEAAwE;IACxE,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;QACd,OAAO,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,GAAG,UAAU,EAAE,CAAC;IACvD,CAAC;IACD,OAAO,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC;AACjD,CAAC;AAPD,wCAOC","sourcesContent":["export type HSL = { h: number, s: number, l: number };\nexport function hslText(color: HSL): string {\n    return `hsl(${color.h}, ${color.s}%, ${color.l}%)`;\n}\n\nexport function hslToRGB(color: HSL) {\n    let { h, s, l } = color;\n    h /= 360;\n    s /= 100;\n    l /= 100;\n    let r, g, b;\n    if (s === 0) {\n        r = g = b = l; // achromatic\n    } else {\n        const hue2rgb = (p: number, q: number, t: number) => {\n            if (t < 0) t += 1;\n            if (t > 1) t -= 1;\n            if (t < 1 / 6) return p + (q - p) * 6 * t;\n            if (t < 1 / 2) return q;\n            if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;\n            return p;\n        };\n        const q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n        const p = 2 * l - q;\n        r = hue2rgb(p, q, h + 1 / 3);\n        g = hue2rgb(p, q, h);\n        b = hue2rgb(p, q, h - 1 / 3);\n        if (b < 0) {\n            b = 0;\n        }\n    }\n    return { r: Math.floor(r * 255), g: Math.floor(g * 255), b: Math.floor(b * 255) };\n}\n\nexport function hslToHex(color: HSL) {\n    let { r, g, b } = hslToRGB(color);\n    const toHex = (x: number) => {\n        const hex = x.toString(16);\n        return hex.length === 1 ? \"0\" + hex : hex;\n    };\n    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;\n}\n\n// Consider \nexport function hslLightenGamma(hsl: HSL, fraction: number) {\n    let l = ((hsl.l ** 2) * (1 + fraction)) ** 0.5;\n    if (l > 255) l = 255;\n    if (!l || l < 0) l = 0;\n    return { h: hsl.h, s: hsl.s, l };\n}\nexport function hslLightenLinear(hsl: HSL, lightness: number) {\n    let l = hsl.l + lightness;\n    if (l > 255) l = 255;\n    if (!l || l < 0) l = 0;\n    return { h: hsl.h, s: hsl.s, l };\n}\nexport function hslDarkenGamma(hsl: HSL, fraction: number) {\n    return hslLightenGamma(hsl, -fraction);\n}\nexport function hslDarkenLinear(hsl: HSL, lightness: number) {\n    return hslLightenLinear(hsl, -lightness);\n}\n\nexport function hslAddSaturate(hsl: HSL, saturation: number) {\n    // If something has ZERO saturation, the color is meaningless, so increasing the saturation\n    //  will likely not give the desired impact. Instead, darken the grey, which should give the desire effect.\n    if (hsl.s === 0) {\n        return hslDarkenGamma(hsl, 0.2);\n    }\n    return { h: hsl.h, s: hsl.s + saturation, l: hsl.l };\n}\nexport function hslSetSaturate(hsl: HSL, saturation: number) {\n    // If something has ZERO saturation, the color is meaningless, so increasing the saturation\n    //  will likely not give the desired impact. Instead, set the lightness.\n    if (hsl.s === 0) {\n        return { h: hsl.h, s: hsl.s, l: 100 - saturation };\n    }\n    return { h: hsl.h, s: saturation, l: hsl.l };\n}"]}
+ /* _JS_SOURCE_HASH = "5f6264067db0d8d369dfb586ba7d3a1cb3888a1196a6dac4c9ef6c835b2337cc"; */