openportal 0.1.1 → 0.1.2

package/web/node_modules/.bun/engine.io@6.6.4/node_modules/engine.io/build/parser-v3/index.js

@@ -1,424 +0,0 @@
-"use strict";
-// imported from https://github.com/socketio/engine.io-parser/tree/2.2.x
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.packets = exports.protocol = void 0;
-exports.encodePacket = encodePacket;
-exports.encodeBase64Packet = encodeBase64Packet;
-exports.decodePacket = decodePacket;
-exports.decodeBase64Packet = decodeBase64Packet;
-exports.encodePayload = encodePayload;
-exports.decodePayload = decodePayload;
-exports.encodePayloadAsBinary = encodePayloadAsBinary;
-exports.decodePayloadAsBinary = decodePayloadAsBinary;
-/**
- * Module dependencies.
- */
-var utf8 = require('./utf8');
-/**
- * Current protocol version.
- */
-exports.protocol = 3;
-const hasBinary = (packets) => {
-    for (const packet of packets) {
-        if (packet.data instanceof ArrayBuffer || ArrayBuffer.isView(packet.data)) {
-            return true;
-        }
-    }
-    return false;
-};
-/**
- * Packet types.
- */
-exports.packets = {
-    open: 0 // non-ws
-    ,
-    close: 1 // non-ws
-    ,
-    ping: 2,
-    pong: 3,
-    message: 4,
-    upgrade: 5,
-    noop: 6
-};
-var packetslist = Object.keys(exports.packets);
-/**
- * Premade error packet.
- */
-var err = { type: 'error', data: 'parser error' };
-const EMPTY_BUFFER = Buffer.concat([]);
-/**
- * Encodes a packet.
- *
- *     <packet type id> [ <data> ]
- *
- * Example:
- *
- *     5hello world
- *     3
- *     4
- *
- * Binary is encoded in an identical principle
- *
- * @api private
- */
-function encodePacket(packet, supportsBinary, utf8encode, callback) {
-    if (typeof supportsBinary === 'function') {
-        callback = supportsBinary;
-        supportsBinary = null;
-    }
-    if (typeof utf8encode === 'function') {
-        callback = utf8encode;
-        utf8encode = null;
-    }
-    if (Buffer.isBuffer(packet.data)) {
-        return encodeBuffer(packet, supportsBinary, callback);
-    }
-    else if (packet.data && (packet.data.buffer || packet.data) instanceof ArrayBuffer) {
-        return encodeBuffer({ type: packet.type, data: arrayBufferToBuffer(packet.data) }, supportsBinary, callback);
-    }
-    // Sending data as a utf-8 string
-    var encoded = exports.packets[packet.type];
-    // data fragment is optional
-    if (undefined !== packet.data) {
-        encoded += utf8encode ? utf8.encode(String(packet.data), { strict: false }) : String(packet.data);
-    }
-    return callback('' + encoded);
-}
-;
-/**
- * Encode Buffer data
- */
-function encodeBuffer(packet, supportsBinary, callback) {
-    if (!supportsBinary) {
-        return encodeBase64Packet(packet, callback);
-    }
-    var data = packet.data;
-    var typeBuffer = Buffer.allocUnsafe(1);
-    typeBuffer[0] = exports.packets[packet.type];
-    return callback(Buffer.concat([typeBuffer, data]));
-}
-/**
- * Encodes a packet with binary data in a base64 string
- *
- * @param {Object} packet, has `type` and `data`
- * @return {String} base64 encoded message
- */
-function encodeBase64Packet(packet, callback) {
-    var data = Buffer.isBuffer(packet.data) ? packet.data : arrayBufferToBuffer(packet.data);
-    var message = 'b' + exports.packets[packet.type];
-    message += data.toString('base64');
-    return callback(message);
-}
-;
-/**
- * Decodes a packet. Data also available as an ArrayBuffer if requested.
- *
- * @return {Object} with `type` and `data` (if any)
- * @api private
- */
-function decodePacket(data, binaryType, utf8decode) {
-    if (data === undefined) {
-        return err;
-    }
-    var type;
-    // String data
-    if (typeof data === 'string') {
-        type = data.charAt(0);
-        if (type === 'b') {
-            return decodeBase64Packet(data.slice(1), binaryType);
-        }
-        if (utf8decode) {
-            data = tryDecode(data);
-            if (data === false) {
-                return err;
-            }
-        }
-        if (Number(type) != type || !packetslist[type]) {
-            return err;
-        }
-        if (data.length > 1) {
-            return { type: packetslist[type], data: data.slice(1) };
-        }
-        else {
-            return { type: packetslist[type] };
-        }
-    }
-    // Binary data
-    if (binaryType === 'arraybuffer') {
-        // wrap Buffer/ArrayBuffer data into an Uint8Array
-        var intArray = new Uint8Array(data);
-        type = intArray[0];
-        return { type: packetslist[type], data: intArray.buffer.slice(1) };
-    }
-    if (data instanceof ArrayBuffer) {
-        data = arrayBufferToBuffer(data);
-    }
-    type = data[0];
-    return { type: packetslist[type], data: data.slice(1) };
-}
-;
-function tryDecode(data) {
-    try {
-        data = utf8.decode(data, { strict: false });
-    }
-    catch (e) {
-        return false;
-    }
-    return data;
-}
-/**
- * Decodes a packet encoded in a base64 string.
- *
- * @param {String} base64 encoded message
- * @return {Object} with `type` and `data` (if any)
- */
-function decodeBase64Packet(msg, binaryType) {
-    var type = packetslist[msg.charAt(0)];
-    var data = Buffer.from(msg.slice(1), 'base64');
-    if (binaryType === 'arraybuffer') {
-        var abv = new Uint8Array(data.length);
-        for (var i = 0; i < abv.length; i++) {
-            abv[i] = data[i];
-        }
-        // @ts-ignore
-        data = abv.buffer;
-    }
-    return { type: type, data: data };
-}
-;
-/**
- * Encodes multiple messages (payload).
- *
- *     <length>:data
- *
- * Example:
- *
- *     11:hello world2:hi
- *
- * If any contents are binary, they will be encoded as base64 strings. Base64
- * encoded strings are marked with a b before the length specifier
- *
- * @param {Array} packets
- * @api private
- */
-function encodePayload(packets, supportsBinary, callback) {
-    if (typeof supportsBinary === 'function') {
-        callback = supportsBinary;
-        supportsBinary = null;
-    }
-    if (supportsBinary && hasBinary(packets)) {
-        return encodePayloadAsBinary(packets, callback);
-    }
-    if (!packets.length) {
-        return callback('0:');
-    }
-    function encodeOne(packet, doneCallback) {
-        encodePacket(packet, supportsBinary, false, function (message) {
-            doneCallback(null, setLengthHeader(message));
-        });
-    }
-    map(packets, encodeOne, function (err, results) {
-        return callback(results.join(''));
-    });
-}
-;
-function setLengthHeader(message) {
-    return message.length + ':' + message;
-}
-/**
- * Async array map using after
- */
-function map(ary, each, done) {
-    const results = new Array(ary.length);
-    let count = 0;
-    for (let i = 0; i < ary.length; i++) {
-        each(ary[i], (error, msg) => {
-            results[i] = msg;
-            if (++count === ary.length) {
-                done(null, results);
-            }
-        });
-    }
-}
-/*
- * Decodes data when a payload is maybe expected. Possible binary contents are
- * decoded from their base64 representation
- *
- * @param {String} data, callback method
- * @api public
- */
-function decodePayload(data, binaryType, callback) {
-    if (typeof data !== 'string') {
-        return decodePayloadAsBinary(data, binaryType, callback);
-    }
-    if (typeof binaryType === 'function') {
-        callback = binaryType;
-        binaryType = null;
-    }
-    if (data === '') {
-        // parser error - ignoring payload
-        return callback(err, 0, 1);
-    }
-    var length = '', n, msg, packet;
-    for (var i = 0, l = data.length; i < l; i++) {
-        var chr = data.charAt(i);
-        if (chr !== ':') {
-            length += chr;
-            continue;
-        }
-        // @ts-ignore
-        if (length === '' || (length != (n = Number(length)))) {
-            // parser error - ignoring payload
-            return callback(err, 0, 1);
-        }
-        msg = data.slice(i + 1, i + 1 + n);
-        if (length != msg.length) {
-            // parser error - ignoring payload
-            return callback(err, 0, 1);
-        }
-        if (msg.length) {
-            packet = decodePacket(msg, binaryType, false);
-            if (err.type === packet.type && err.data === packet.data) {
-                // parser error in individual packet - ignoring payload
-                return callback(err, 0, 1);
-            }
-            var more = callback(packet, i + n, l);
-            if (false === more)
-                return;
-        }
-        // advance cursor
-        i += n;
-        length = '';
-    }
-    if (length !== '') {
-        // parser error - ignoring payload
-        return callback(err, 0, 1);
-    }
-}
-;
-/**
- *
- * Converts a buffer to a utf8.js encoded string
- *
- * @api private
- */
-function bufferToString(buffer) {
-    var str = '';
-    for (var i = 0, l = buffer.length; i < l; i++) {
-        str += String.fromCharCode(buffer[i]);
-    }
-    return str;
-}
-/**
- *
- * Converts a utf8.js encoded string to a buffer
- *
- * @api private
- */
-function stringToBuffer(string) {
-    var buf = Buffer.allocUnsafe(string.length);
-    for (var i = 0, l = string.length; i < l; i++) {
-        buf.writeUInt8(string.charCodeAt(i), i);
-    }
-    return buf;
-}
-/**
- *
- * Converts an ArrayBuffer to a Buffer
- *
- * @api private
- */
-function arrayBufferToBuffer(data) {
-    // data is either an ArrayBuffer or ArrayBufferView.
-    var length = data.byteLength || data.length;
-    var offset = data.byteOffset || 0;
-    return Buffer.from(data.buffer || data, offset, length);
-}
-/**
- * Encodes multiple messages (payload) as binary.
- *
- * <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number
- * 255><data>
- *
- * Example:
- * 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers
- *
- * @param {Array} packets
- * @return {Buffer} encoded payload
- * @api private
- */
-function encodePayloadAsBinary(packets, callback) {
-    if (!packets.length) {
-        return callback(EMPTY_BUFFER);
-    }
-    map(packets, encodeOneBinaryPacket, function (err, results) {
-        return callback(Buffer.concat(results));
-    });
-}
-;
-function encodeOneBinaryPacket(p, doneCallback) {
-    function onBinaryPacketEncode(packet) {
-        var encodingLength = '' + packet.length;
-        var sizeBuffer;
-        if (typeof packet === 'string') {
-            sizeBuffer = Buffer.allocUnsafe(encodingLength.length + 2);
-            sizeBuffer[0] = 0; // is a string (not true binary = 0)
-            for (var i = 0; i < encodingLength.length; i++) {
-                sizeBuffer[i + 1] = parseInt(encodingLength[i], 10);
-            }
-            sizeBuffer[sizeBuffer.length - 1] = 255;
-            return doneCallback(null, Buffer.concat([sizeBuffer, stringToBuffer(packet)]));
-        }
-        sizeBuffer = Buffer.allocUnsafe(encodingLength.length + 2);
-        sizeBuffer[0] = 1; // is binary (true binary = 1)
-        for (var i = 0; i < encodingLength.length; i++) {
-            sizeBuffer[i + 1] = parseInt(encodingLength[i], 10);
-        }
-        sizeBuffer[sizeBuffer.length - 1] = 255;
-        doneCallback(null, Buffer.concat([sizeBuffer, packet]));
-    }
-    encodePacket(p, true, true, onBinaryPacketEncode);
-}
-/*
- * Decodes data when a payload is maybe expected. Strings are decoded by
- * interpreting each byte as a key code for entries marked to start with 0. See
- * description of encodePayloadAsBinary
-
- * @param {Buffer} data, callback method
- * @api public
- */
-function decodePayloadAsBinary(data, binaryType, callback) {
-    if (typeof binaryType === 'function') {
-        callback = binaryType;
-        binaryType = null;
-    }
-    var bufferTail = data;
-    var buffers = [];
-    var i;
-    while (bufferTail.length > 0) {
-        var strLen = '';
-        var isString = bufferTail[0] === 0;
-        for (i = 1;; i++) {
-            if (bufferTail[i] === 255)
-                break;
-            // 310 = char length of Number.MAX_VALUE
-            if (strLen.length > 310) {
-                return callback(err, 0, 1);
-            }
-            strLen += '' + bufferTail[i];
-        }
-        bufferTail = bufferTail.slice(strLen.length + 1);
-        var msgLength = parseInt(strLen, 10);
-        var msg = bufferTail.slice(1, msgLength + 1);
-        if (isString)
-            msg = bufferToString(msg);
-        buffers.push(msg);
-        bufferTail = bufferTail.slice(msgLength + 1);
-    }
-    var total = buffers.length;
-    for (i = 0; i < total; i++) {
-        var buffer = buffers[i];
-        callback(decodePacket(buffer, binaryType, true), i, total);
-    }
-}
-;

package/web/node_modules/.bun/engine.io@6.6.4/node_modules/engine.io/build/parser-v3/utf8.js

@@ -1,187 +0,0 @@
-/*! https://mths.be/utf8js v2.1.2 by @mathias */
-var stringFromCharCode = String.fromCharCode;
-// Taken from https://mths.be/punycode
-function ucs2decode(string) {
-    var output = [];
-    var counter = 0;
-    var length = string.length;
-    var value;
-    var extra;
-    while (counter < length) {
-        value = string.charCodeAt(counter++);
-        if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
-            // high surrogate, and there is a next character
-            extra = string.charCodeAt(counter++);
-            if ((extra & 0xFC00) == 0xDC00) { // low surrogate
-                output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
-            }
-            else {
-                // unmatched surrogate; only append this code unit, in case the next
-                // code unit is the high surrogate of a surrogate pair
-                output.push(value);
-                counter--;
-            }
-        }
-        else {
-            output.push(value);
-        }
-    }
-    return output;
-}
-// Taken from https://mths.be/punycode
-function ucs2encode(array) {
-    var length = array.length;
-    var index = -1;
-    var value;
-    var output = '';
-    while (++index < length) {
-        value = array[index];
-        if (value > 0xFFFF) {
-            value -= 0x10000;
-            output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
-            value = 0xDC00 | value & 0x3FF;
-        }
-        output += stringFromCharCode(value);
-    }
-    return output;
-}
-function checkScalarValue(codePoint, strict) {
-    if (codePoint >= 0xD800 && codePoint <= 0xDFFF) {
-        if (strict) {
-            throw Error('Lone surrogate U+' + codePoint.toString(16).toUpperCase() +
-                ' is not a scalar value');
-        }
-        return false;
-    }
-    return true;
-}
-/*--------------------------------------------------------------------------*/
-function createByte(codePoint, shift) {
-    return stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);
-}
-function encodeCodePoint(codePoint, strict) {
-    if ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence
-        return stringFromCharCode(codePoint);
-    }
-    var symbol = '';
-    if ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence
-        symbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);
-    }
-    else if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence
-        if (!checkScalarValue(codePoint, strict)) {
-            codePoint = 0xFFFD;
-        }
-        symbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);
-        symbol += createByte(codePoint, 6);
-    }
-    else if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence
-        symbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);
-        symbol += createByte(codePoint, 12);
-        symbol += createByte(codePoint, 6);
-    }
-    symbol += stringFromCharCode((codePoint & 0x3F) | 0x80);
-    return symbol;
-}
-function utf8encode(string, opts) {
-    opts = opts || {};
-    var strict = false !== opts.strict;
-    var codePoints = ucs2decode(string);
-    var length = codePoints.length;
-    var index = -1;
-    var codePoint;
-    var byteString = '';
-    while (++index < length) {
-        codePoint = codePoints[index];
-        byteString += encodeCodePoint(codePoint, strict);
-    }
-    return byteString;
-}
-/*--------------------------------------------------------------------------*/
-function readContinuationByte() {
-    if (byteIndex >= byteCount) {
-        throw Error('Invalid byte index');
-    }
-    var continuationByte = byteArray[byteIndex] & 0xFF;
-    byteIndex++;
-    if ((continuationByte & 0xC0) == 0x80) {
-        return continuationByte & 0x3F;
-    }
-    // If we end up here, it’s not a continuation byte
-    throw Error('Invalid continuation byte');
-}
-function decodeSymbol(strict) {
-    var byte1;
-    var byte2;
-    var byte3;
-    var byte4;
-    var codePoint;
-    if (byteIndex > byteCount) {
-        throw Error('Invalid byte index');
-    }
-    if (byteIndex == byteCount) {
-        return false;
-    }
-    // Read first byte
-    byte1 = byteArray[byteIndex] & 0xFF;
-    byteIndex++;
-    // 1-byte sequence (no continuation bytes)
-    if ((byte1 & 0x80) == 0) {
-        return byte1;
-    }
-    // 2-byte sequence
-    if ((byte1 & 0xE0) == 0xC0) {
-        byte2 = readContinuationByte();
-        codePoint = ((byte1 & 0x1F) << 6) | byte2;
-        if (codePoint >= 0x80) {
-            return codePoint;
-        }
-        else {
-            throw Error('Invalid continuation byte');
-        }
-    }
-    // 3-byte sequence (may include unpaired surrogates)
-    if ((byte1 & 0xF0) == 0xE0) {
-        byte2 = readContinuationByte();
-        byte3 = readContinuationByte();
-        codePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;
-        if (codePoint >= 0x0800) {
-            return checkScalarValue(codePoint, strict) ? codePoint : 0xFFFD;
-        }
-        else {
-            throw Error('Invalid continuation byte');
-        }
-    }
-    // 4-byte sequence
-    if ((byte1 & 0xF8) == 0xF0) {
-        byte2 = readContinuationByte();
-        byte3 = readContinuationByte();
-        byte4 = readContinuationByte();
-        codePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |
-            (byte3 << 0x06) | byte4;
-        if (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {
-            return codePoint;
-        }
-    }
-    throw Error('Invalid UTF-8 detected');
-}
-var byteArray;
-var byteCount;
-var byteIndex;
-function utf8decode(byteString, opts) {
-    opts = opts || {};
-    var strict = false !== opts.strict;
-    byteArray = ucs2decode(byteString);
-    byteCount = byteArray.length;
-    byteIndex = 0;
-    var codePoints = [];
-    var tmp;
-    while ((tmp = decodeSymbol(strict)) !== false) {
-        codePoints.push(tmp);
-    }
-    return ucs2encode(codePoints);
-}
-module.exports = {
-    version: '2.1.2',
-    encode: utf8encode,
-    decode: utf8decode
-};