openportal 0.1.1 → 0.1.2

package/web/node_modules/.bun/engine.io@6.6.4/node_modules/engine.io/build/socket.js

@@ -1,460 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Socket = void 0;
-const events_1 = require("events");
-const debug_1 = require("debug");
-const timers_1 = require("timers");
-const debug = (0, debug_1.default)("engine:socket");
-class Socket extends events_1.EventEmitter {
-    get readyState() {
-        return this._readyState;
-    }
-    set readyState(state) {
-        debug("readyState updated from %s to %s", this._readyState, state);
-        this._readyState = state;
-    }
-    constructor(id, server, transport, req, protocol) {
-        super();
-        /**
-         * The current state of the socket.
-         */
-        this._readyState = "opening";
-        /* private */ this.upgrading = false;
-        /* private */ this.upgraded = false;
-        this.writeBuffer = [];
-        this.packetsFn = [];
-        this.sentCallbackFn = [];
-        this.cleanupFn = [];
-        this.id = id;
-        this.server = server;
-        this.request = req;
-        this.protocol = protocol;
-        // Cache IP since it might not be in the req later
-        if (req) {
-            if (req.websocket && req.websocket._socket) {
-                this.remoteAddress = req.websocket._socket.remoteAddress;
-            }
-            else {
-                this.remoteAddress = req.connection.remoteAddress;
-            }
-        }
-        else {
-            // TODO there is currently no way to get the IP address of the client when it connects with WebTransport
-            //  see https://github.com/fails-components/webtransport/issues/114
-        }
-        this.pingTimeoutTimer = null;
-        this.pingIntervalTimer = null;
-        this.setTransport(transport);
-        this.onOpen();
-    }
-    /**
-     * Called upon transport considered open.
-     *
-     * @private
-     */
-    onOpen() {
-        this.readyState = "open";
-        // sends an `open` packet
-        this.transport.sid = this.id;
-        this.sendPacket("open", JSON.stringify({
-            sid: this.id,
-            upgrades: this.getAvailableUpgrades(),
-            pingInterval: this.server.opts.pingInterval,
-            pingTimeout: this.server.opts.pingTimeout,
-            maxPayload: this.server.opts.maxHttpBufferSize,
-        }));
-        if (this.server.opts.initialPacket) {
-            this.sendPacket("message", this.server.opts.initialPacket);
-        }
-        this.emit("open");
-        if (this.protocol === 3) {
-            // in protocol v3, the client sends a ping, and the server answers with a pong
-            this.resetPingTimeout();
-        }
-        else {
-            // in protocol v4, the server sends a ping, and the client answers with a pong
-            this.schedulePing();
-        }
-    }
-    /**
-     * Called upon transport packet.
-     *
-     * @param {Object} packet
-     * @private
-     */
-    onPacket(packet) {
-        if ("open" !== this.readyState) {
-            return debug("packet received with closed socket");
-        }
-        // export packet event
-        debug(`received packet ${packet.type}`);
-        this.emit("packet", packet);
-        switch (packet.type) {
-            case "ping":
-                if (this.transport.protocol !== 3) {
-                    this.onError(new Error("invalid heartbeat direction"));
-                    return;
-                }
-                debug("got ping");
-                this.pingTimeoutTimer.refresh();
-                this.sendPacket("pong");
-                this.emit("heartbeat");
-                break;
-            case "pong":
-                if (this.transport.protocol === 3) {
-                    this.onError(new Error("invalid heartbeat direction"));
-                    return;
-                }
-                debug("got pong");
-                (0, timers_1.clearTimeout)(this.pingTimeoutTimer);
-                this.pingIntervalTimer.refresh();
-                this.emit("heartbeat");
-                break;
-            case "error":
-                this.onClose("parse error");
-                break;
-            case "message":
-                this.emit("data", packet.data);
-                this.emit("message", packet.data);
-                break;
-        }
-    }
-    /**
-     * Called upon transport error.
-     *
-     * @param {Error} err - error object
-     * @private
-     */
-    onError(err) {
-        debug("transport error");
-        this.onClose("transport error", err);
-    }
-    /**
-     * Pings client every `this.pingInterval` and expects response
-     * within `this.pingTimeout` or closes connection.
-     *
-     * @private
-     */
-    schedulePing() {
-        this.pingIntervalTimer = (0, timers_1.setTimeout)(() => {
-            debug("writing ping packet - expecting pong within %sms", this.server.opts.pingTimeout);
-            this.sendPacket("ping");
-            this.resetPingTimeout();
-        }, this.server.opts.pingInterval);
-    }
-    /**
-     * Resets ping timeout.
-     *
-     * @private
-     */
-    resetPingTimeout() {
-        (0, timers_1.clearTimeout)(this.pingTimeoutTimer);
-        this.pingTimeoutTimer = (0, timers_1.setTimeout)(() => {
-            if (this.readyState === "closed")
-                return;
-            this.onClose("ping timeout");
-        }, this.protocol === 3
-            ? this.server.opts.pingInterval + this.server.opts.pingTimeout
-            : this.server.opts.pingTimeout);
-    }
-    /**
-     * Attaches handlers for the given transport.
-     *
-     * @param {Transport} transport
-     * @private
-     */
-    setTransport(transport) {
-        const onError = this.onError.bind(this);
-        const onReady = () => this.flush();
-        const onPacket = this.onPacket.bind(this);
-        const onDrain = this.onDrain.bind(this);
-        const onClose = this.onClose.bind(this, "transport close");
-        this.transport = transport;
-        this.transport.once("error", onError);
-        this.transport.on("ready", onReady);
-        this.transport.on("packet", onPacket);
-        this.transport.on("drain", onDrain);
-        this.transport.once("close", onClose);
-        this.cleanupFn.push(function () {
-            transport.removeListener("error", onError);
-            transport.removeListener("ready", onReady);
-            transport.removeListener("packet", onPacket);
-            transport.removeListener("drain", onDrain);
-            transport.removeListener("close", onClose);
-        });
-    }
-    /**
-     * Upon transport "drain" event
-     *
-     * @private
-     */
-    onDrain() {
-        if (this.sentCallbackFn.length > 0) {
-            debug("executing batch send callback");
-            const seqFn = this.sentCallbackFn.shift();
-            if (seqFn) {
-                for (let i = 0; i < seqFn.length; i++) {
-                    seqFn[i](this.transport);
-                }
-            }
-        }
-    }
-    /**
-     * Upgrades socket to the given transport
-     *
-     * @param {Transport} transport
-     * @private
-     */
-    /* private */ _maybeUpgrade(transport) {
-        debug('might upgrade socket transport from "%s" to "%s"', this.transport.name, transport.name);
-        this.upgrading = true;
-        // set transport upgrade timer
-        const upgradeTimeoutTimer = (0, timers_1.setTimeout)(() => {
-            debug("client did not complete upgrade - closing transport");
-            cleanup();
-            if ("open" === transport.readyState) {
-                transport.close();
-            }
-        }, this.server.opts.upgradeTimeout);
-        let checkIntervalTimer;
-        const onPacket = (packet) => {
-            if ("ping" === packet.type && "probe" === packet.data) {
-                debug("got probe ping packet, sending pong");
-                transport.send([{ type: "pong", data: "probe" }]);
-                this.emit("upgrading", transport);
-                clearInterval(checkIntervalTimer);
-                checkIntervalTimer = setInterval(check, 100);
-            }
-            else if ("upgrade" === packet.type && this.readyState !== "closed") {
-                debug("got upgrade packet - upgrading");
-                cleanup();
-                this.transport.discard();
-                this.upgraded = true;
-                this.clearTransport();
-                this.setTransport(transport);
-                this.emit("upgrade", transport);
-                this.flush();
-                if (this.readyState === "closing") {
-                    transport.close(() => {
-                        this.onClose("forced close");
-                    });
-                }
-            }
-            else {
-                cleanup();
-                transport.close();
-            }
-        };
-        // we force a polling cycle to ensure a fast upgrade
-        const check = () => {
-            if ("polling" === this.transport.name && this.transport.writable) {
-                debug("writing a noop packet to polling for fast upgrade");
-                this.transport.send([{ type: "noop" }]);
-            }
-        };
-        const cleanup = () => {
-            this.upgrading = false;
-            clearInterval(checkIntervalTimer);
-            (0, timers_1.clearTimeout)(upgradeTimeoutTimer);
-            transport.removeListener("packet", onPacket);
-            transport.removeListener("close", onTransportClose);
-            transport.removeListener("error", onError);
-            this.removeListener("close", onClose);
-        };
-        const onError = (err) => {
-            debug("client did not complete upgrade - %s", err);
-            cleanup();
-            transport.close();
-            transport = null;
-        };
-        const onTransportClose = () => {
-            onError("transport closed");
-        };
-        const onClose = () => {
-            onError("socket closed");
-        };
-        transport.on("packet", onPacket);
-        transport.once("close", onTransportClose);
-        transport.once("error", onError);
-        this.once("close", onClose);
-    }
-    /**
-     * Clears listeners and timers associated with current transport.
-     *
-     * @private
-     */
-    clearTransport() {
-        let cleanup;
-        const toCleanUp = this.cleanupFn.length;
-        for (let i = 0; i < toCleanUp; i++) {
-            cleanup = this.cleanupFn.shift();
-            cleanup();
-        }
-        // silence further transport errors and prevent uncaught exceptions
-        this.transport.on("error", function () {
-            debug("error triggered by discarded transport");
-        });
-        // ensure transport won't stay open
-        this.transport.close();
-        (0, timers_1.clearTimeout)(this.pingTimeoutTimer);
-    }
-    /**
-     * Called upon transport considered closed.
-     * Possible reasons: `ping timeout`, `client error`, `parse error`,
-     * `transport error`, `server close`, `transport close`
-     */
-    onClose(reason, description) {
-        if ("closed" !== this.readyState) {
-            this.readyState = "closed";
-            // clear timers
-            (0, timers_1.clearTimeout)(this.pingIntervalTimer);
-            (0, timers_1.clearTimeout)(this.pingTimeoutTimer);
-            // clean writeBuffer in next tick, so developers can still
-            // grab the writeBuffer on 'close' event
-            process.nextTick(() => {
-                this.writeBuffer = [];
-            });
-            this.packetsFn = [];
-            this.sentCallbackFn = [];
-            this.clearTransport();
-            this.emit("close", reason, description);
-        }
-    }
-    /**
-     * Sends a message packet.
-     *
-     * @param {Object} data
-     * @param {Object} options
-     * @param {Function} callback
-     * @return {Socket} for chaining
-     */
-    send(data, options, callback) {
-        this.sendPacket("message", data, options, callback);
-        return this;
-    }
-    /**
-     * Alias of {@link send}.
-     *
-     * @param data
-     * @param options
-     * @param callback
-     */
-    write(data, options, callback) {
-        this.sendPacket("message", data, options, callback);
-        return this;
-    }
-    /**
-     * Sends a packet.
-     *
-     * @param {String} type - packet type
-     * @param {String} data
-     * @param {Object} options
-     * @param {Function} callback
-     *
-     * @private
-     */
-    sendPacket(type, data, options = {}, callback) {
-        if ("function" === typeof options) {
-            callback = options;
-            options = {};
-        }
-        if ("closing" !== this.readyState && "closed" !== this.readyState) {
-            debug('sending packet "%s" (%s)', type, data);
-            // compression is enabled by default
-            options.compress = options.compress !== false;
-            const packet = {
-                type,
-                options: options,
-            };
-            if (data)
-                packet.data = data;
-            // exports packetCreate event
-            this.emit("packetCreate", packet);
-            this.writeBuffer.push(packet);
-            // add send callback to object, if defined
-            if ("function" === typeof callback)
-                this.packetsFn.push(callback);
-            this.flush();
-        }
-    }
-    /**
-     * Attempts to flush the packets buffer.
-     *
-     * @private
-     */
-    flush() {
-        if ("closed" !== this.readyState &&
-            this.transport.writable &&
-            this.writeBuffer.length) {
-            debug("flushing buffer to transport");
-            this.emit("flush", this.writeBuffer);
-            this.server.emit("flush", this, this.writeBuffer);
-            const wbuf = this.writeBuffer;
-            this.writeBuffer = [];
-            if (this.packetsFn.length) {
-                this.sentCallbackFn.push(this.packetsFn);
-                this.packetsFn = [];
-            }
-            else {
-                this.sentCallbackFn.push(null);
-            }
-            this.transport.send(wbuf);
-            this.emit("drain");
-            this.server.emit("drain", this);
-        }
-    }
-    /**
-     * Get available upgrades for this socket.
-     *
-     * @private
-     */
-    getAvailableUpgrades() {
-        const availableUpgrades = [];
-        const allUpgrades = this.server.upgrades(this.transport.name);
-        for (let i = 0; i < allUpgrades.length; ++i) {
-            const upg = allUpgrades[i];
-            if (this.server.opts.transports.indexOf(upg) !== -1) {
-                availableUpgrades.push(upg);
-            }
-        }
-        return availableUpgrades;
-    }
-    /**
-     * Closes the socket and underlying transport.
-     *
-     * @param {Boolean} discard - optional, discard the transport
-     * @return {Socket} for chaining
-     */
-    close(discard) {
-        if (discard &&
-            (this.readyState === "open" || this.readyState === "closing")) {
-            return this.closeTransport(discard);
-        }
-        if ("open" !== this.readyState)
-            return;
-        this.readyState = "closing";
-        if (this.writeBuffer.length) {
-            debug("there are %d remaining packets in the buffer, waiting for the 'drain' event", this.writeBuffer.length);
-            this.once("drain", () => {
-                debug("all packets have been sent, closing the transport");
-                this.closeTransport(discard);
-            });
-            return;
-        }
-        debug("the buffer is empty, closing the transport right away");
-        this.closeTransport(discard);
-    }
-    /**
-     * Closes the underlying transport.
-     *
-     * @param {Boolean} discard
-     * @private
-     */
-    closeTransport(discard) {
-        debug("closing the transport (discard? %s)", !!discard);
-        if (discard)
-            this.transport.discard();
-        this.transport.close(this.onClose.bind(this, "forced close"));
-    }
-}
-exports.Socket = Socket;

package/web/node_modules/.bun/engine.io@6.6.4/node_modules/engine.io/build/transport.js

@@ -1,117 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transport = void 0;
-const events_1 = require("events");
-const parser_v4 = require("engine.io-parser");
-const parser_v3 = require("./parser-v3/index");
-const debug_1 = require("debug");
-const debug = (0, debug_1.default)("engine:transport");
-function noop() { }
-class Transport extends events_1.EventEmitter {
-    get readyState() {
-        return this._readyState;
-    }
-    set readyState(state) {
-        debug("readyState updated from %s to %s (%s)", this._readyState, state, this.name);
-        this._readyState = state;
-    }
-    /**
-     * Transport constructor.
-     *
-     * @param {EngineRequest} req
-     */
-    constructor(req) {
-        super();
-        /**
-         * Whether the transport is currently ready to send packets.
-         */
-        this.writable = false;
-        /**
-         * The current state of the transport.
-         * @protected
-         */
-        this._readyState = "open";
-        /**
-         * Whether the transport is discarded and can be safely closed (used during upgrade).
-         * @protected
-         */
-        this.discarded = false;
-        this.protocol = req._query.EIO === "4" ? 4 : 3; // 3rd revision by default
-        this.parser = this.protocol === 4 ? parser_v4 : parser_v3;
-        this.supportsBinary = !(req._query && req._query.b64);
-    }
-    /**
-     * Flags the transport as discarded.
-     *
-     * @package
-     */
-    discard() {
-        this.discarded = true;
-    }
-    /**
-     * Called with an incoming HTTP request.
-     *
-     * @param req
-     * @package
-     */
-    onRequest(req) { }
-    /**
-     * Closes the transport.
-     *
-     * @package
-     */
-    close(fn) {
-        if ("closed" === this.readyState || "closing" === this.readyState)
-            return;
-        this.readyState = "closing";
-        this.doClose(fn || noop);
-    }
-    /**
-     * Called with a transport error.
-     *
-     * @param {String} msg - message error
-     * @param {Object} desc - error description
-     * @protected
-     */
-    onError(msg, desc) {
-        if (this.listeners("error").length) {
-            const err = new Error(msg);
-            // @ts-ignore
-            err.type = "TransportError";
-            // @ts-ignore
-            err.description = desc;
-            this.emit("error", err);
-        }
-        else {
-            debug("ignored transport error %s (%s)", msg, desc);
-        }
-    }
-    /**
-     * Called with parsed out a packets from the data stream.
-     *
-     * @param {Object} packet
-     * @protected
-     */
-    onPacket(packet) {
-        this.emit("packet", packet);
-    }
-    /**
-     * Called with the encoded packet data.
-     *
-     * @param {String} data
-     * @protected
-     */
-    onData(data) {
-        this.onPacket(this.parser.decodePacket(data));
-    }
-    /**
-     * Called upon transport close.
-     *
-     * @protected
-     */
-    onClose() {
-        this.readyState = "closed";
-        this.emit("close");
-    }
-}
-exports.Transport = Transport;

package/web/node_modules/.bun/engine.io@6.6.4/node_modules/engine.io/build/transports/index.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const polling_1 = require("./polling");
-const polling_jsonp_1 = require("./polling-jsonp");
-const websocket_1 = require("./websocket");
-const webtransport_1 = require("./webtransport");
-exports.default = {
-    polling: polling,
-    websocket: websocket_1.WebSocket,
-    webtransport: webtransport_1.WebTransport,
-};
-/**
- * Polling polymorphic constructor.
- */
-function polling(req) {
-    if ("string" === typeof req._query.j) {
-        return new polling_jsonp_1.JSONP(req);
-    }
-    else {
-        return new polling_1.Polling(req);
-    }
-}
-polling.upgradesTo = ["websocket", "webtransport"];

package/web/node_modules/.bun/engine.io@6.6.4/node_modules/engine.io/build/transports/polling-jsonp.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JSONP = void 0;
-const polling_1 = require("./polling");
-const qs = require("querystring");
-const rDoubleSlashes = /\\\\n/g;
-const rSlashes = /(\\)?\\n/g;
-class JSONP extends polling_1.Polling {
-    /**
-     * JSON-P polling transport.
-     */
-    constructor(req) {
-        super(req);
-        this.head = "___eio[" + (req._query.j || "").replace(/[^0-9]/g, "") + "](";
-        this.foot = ");";
-    }
-    onData(data) {
-        // we leverage the qs module so that we get built-in DoS protection
-        // and the fast alternative to decodeURIComponent
-        data = qs.parse(data).d;
-        if ("string" === typeof data) {
-            // client will send already escaped newlines as \\\\n and newlines as \\n
-            // \\n must be replaced with \n and \\\\n with \\n
-            data = data.replace(rSlashes, function (match, slashes) {
-                return slashes ? match : "\n";
-            });
-            super.onData(data.replace(rDoubleSlashes, "\\n"));
-        }
-    }
-    doWrite(data, options, callback) {
-        // we must output valid javascript, not valid json
-        // see: http://timelessrepo.com/json-isnt-a-javascript-subset
-        const js = JSON.stringify(data)
-            .replace(/\u2028/g, "\\u2028")
-            .replace(/\u2029/g, "\\u2029");
-        // prepare response
-        data = this.head + js + this.foot;
-        super.doWrite(data, options, callback);
-    }
-}
-exports.JSONP = JSONP;