@wabot-dev/framework 0.0.14 → 0.0.16

package/dist/src/node_modules/engine.io-client/build/esm/transports/websocket.node.js

@@ -1,48 +0,0 @@
-import '../../../../../_virtual/stream.js';
-import '../../../../../_virtual/receiver.js';
-import '../../../../../_virtual/sender.js';
-import WebSocket from '../../../../../_virtual/websocket.js';
-import '../../../../../_virtual/websocket-server.js';
-import { BaseWS } from './websocket.js';
-
-/**
- * WebSocket transport based on the `WebSocket` object provided by the `ws` package.
- *
- * Usage: Node.js, Deno (compat), Bun (compat)
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
- * @see https://caniuse.com/mdn-api_websocket
- */
-class WS extends BaseWS {
-    createSocket(uri, protocols, opts) {
-        var _a;
-        if ((_a = this.socket) === null || _a === void 0 ? void 0 : _a._cookieJar) {
-            opts.headers = opts.headers || {};
-            opts.headers.cookie =
-                typeof opts.headers.cookie === "string"
-                    ? [opts.headers.cookie]
-                    : opts.headers.cookie || [];
-            for (const [name, cookie] of this.socket._cookieJar.cookies) {
-                opts.headers.cookie.push(`${name}=${cookie.value}`);
-            }
-        }
-        return new WebSocket(uri, protocols, opts);
-    }
-    doWrite(packet, data) {
-        const opts = {};
-        if (packet.options) {
-            opts.compress = packet.options.compress;
-        }
-        if (this.opts.perMessageDeflate) {
-            const len = 
-            // @ts-ignore
-            "string" === typeof data ? Buffer.byteLength(data) : data.length;
-            if (len < this.opts.perMessageDeflate.threshold) {
-                opts.compress = false;
-            }
-        }
-        this.ws.send(data, opts);
-    }
-}
-
-export { WS };

package/dist/src/node_modules/engine.io-client/build/esm/transports/webtransport.js

@@ -1,83 +0,0 @@
-import { Transport } from '../transport.js';
-import { nextTick } from '../globals.node.js';
-import { createPacketDecoderStream, createPacketEncoderStream } from '../../../../engine.io-parser/build/esm/index.js';
-
-/**
- * WebTransport transport based on the built-in `WebTransport` object.
- *
- * Usage: browser, Node.js (with the `@fails-components/webtransport` package)
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/API/WebTransport
- * @see https://caniuse.com/webtransport
- */
-class WT extends Transport {
-    get name() {
-        return "webtransport";
-    }
-    doOpen() {
-        try {
-            // @ts-ignore
-            this._transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]);
-        }
-        catch (err) {
-            return this.emitReserved("error", err);
-        }
-        this._transport.closed
-            .then(() => {
-            this.onClose();
-        })
-            .catch((err) => {
-            this.onError("webtransport error", err);
-        });
-        // note: we could have used async/await, but that would require some additional polyfills
-        this._transport.ready.then(() => {
-            this._transport.createBidirectionalStream().then((stream) => {
-                const decoderStream = createPacketDecoderStream(Number.MAX_SAFE_INTEGER, this.socket.binaryType);
-                const reader = stream.readable.pipeThrough(decoderStream).getReader();
-                const encoderStream = createPacketEncoderStream();
-                encoderStream.readable.pipeTo(stream.writable);
-                this._writer = encoderStream.writable.getWriter();
-                const read = () => {
-                    reader
-                        .read()
-                        .then(({ done, value }) => {
-                        if (done) {
-                            return;
-                        }
-                        this.onPacket(value);
-                        read();
-                    })
-                        .catch((err) => {
-                    });
-                };
-                read();
-                const packet = { type: "open" };
-                if (this.query.sid) {
-                    packet.data = `{"sid":"${this.query.sid}"}`;
-                }
-                this._writer.write(packet).then(() => this.onOpen());
-            });
-        });
-    }
-    write(packets) {
-        this.writable = false;
-        for (let i = 0; i < packets.length; i++) {
-            const packet = packets[i];
-            const lastPacket = i === packets.length - 1;
-            this._writer.write(packet).then(() => {
-                if (lastPacket) {
-                    nextTick(() => {
-                        this.writable = true;
-                        this.emitReserved("drain");
-                    }, this.setTimeoutFn);
-                }
-            });
-        }
-    }
-    doClose() {
-        var _a;
-        (_a = this._transport) === null || _a === void 0 ? void 0 : _a.close();
-    }
-}
-
-export { WT };

package/dist/src/node_modules/engine.io-client/build/esm/util.js

@@ -1,62 +0,0 @@
-import { globalThisShim } from './globals.node.js';
-
-function pick(obj, ...attr) {
-    return attr.reduce((acc, k) => {
-        if (obj.hasOwnProperty(k)) {
-            acc[k] = obj[k];
-        }
-        return acc;
-    }, {});
-}
-// Keep a reference to the real timeout functions so they can be used when overridden
-const NATIVE_SET_TIMEOUT = globalThisShim.setTimeout;
-const NATIVE_CLEAR_TIMEOUT = globalThisShim.clearTimeout;
-function installTimerFunctions(obj, opts) {
-    if (opts.useNativeTimers) {
-        obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThisShim);
-        obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThisShim);
-    }
-    else {
-        obj.setTimeoutFn = globalThisShim.setTimeout.bind(globalThisShim);
-        obj.clearTimeoutFn = globalThisShim.clearTimeout.bind(globalThisShim);
-    }
-}
-// base64 encoded buffers are about 33% bigger (https://en.wikipedia.org/wiki/Base64)
-const BASE64_OVERHEAD = 1.33;
-// we could also have used `new Blob([obj]).size`, but it isn't supported in IE9
-function byteLength(obj) {
-    if (typeof obj === "string") {
-        return utf8Length(obj);
-    }
-    // arraybuffer or blob
-    return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD);
-}
-function utf8Length(str) {
-    let c = 0, length = 0;
-    for (let i = 0, l = str.length; i < l; i++) {
-        c = str.charCodeAt(i);
-        if (c < 0x80) {
-            length += 1;
-        }
-        else if (c < 0x800) {
-            length += 2;
-        }
-        else if (c < 0xd800 || c >= 0xe000) {
-            length += 3;
-        }
-        else {
-            i++;
-            length += 4;
-        }
-    }
-    return length;
-}
-/**
- * Generates a random 8-characters string.
- */
-function randomString() {
-    return (Date.now().toString(36).substring(3) +
-        Math.random().toString(36).substring(2, 5));
-}
-
-export { byteLength, installTimerFunctions, pick, randomString };

package/dist/src/node_modules/engine.io-client/node_modules/ws/lib/buffer-util.js

@@ -1,142 +0,0 @@
-import { __module as bufferUtil } from '../../../../../_virtual/buffer-util.js';
-import { __require as requireConstants } from './constants.js';
-
-var hasRequiredBufferUtil;
-
-function requireBufferUtil () {
-	if (hasRequiredBufferUtil) return bufferUtil.exports;
-	hasRequiredBufferUtil = 1;
-
-	const { EMPTY_BUFFER } = requireConstants();
-
-	const FastBuffer = Buffer[Symbol.species];
-
-	/**
-	 * Merges an array of buffers into a new buffer.
-	 *
-	 * @param {Buffer[]} list The array of buffers to concat
-	 * @param {Number} totalLength The total length of buffers in the list
-	 * @return {Buffer} The resulting buffer
-	 * @public
-	 */
-	function concat(list, totalLength) {
-	  if (list.length === 0) return EMPTY_BUFFER;
-	  if (list.length === 1) return list[0];
-
-	  const target = Buffer.allocUnsafe(totalLength);
-	  let offset = 0;
-
-	  for (let i = 0; i < list.length; i++) {
-	    const buf = list[i];
-	    target.set(buf, offset);
-	    offset += buf.length;
-	  }
-
-	  if (offset < totalLength) {
-	    return new FastBuffer(target.buffer, target.byteOffset, offset);
-	  }
-
-	  return target;
-	}
-
-	/**
-	 * Masks a buffer using the given mask.
-	 *
-	 * @param {Buffer} source The buffer to mask
-	 * @param {Buffer} mask The mask to use
-	 * @param {Buffer} output The buffer where to store the result
-	 * @param {Number} offset The offset at which to start writing
-	 * @param {Number} length The number of bytes to mask.
-	 * @public
-	 */
-	function _mask(source, mask, output, offset, length) {
-	  for (let i = 0; i < length; i++) {
-	    output[offset + i] = source[i] ^ mask[i & 3];
-	  }
-	}
-
-	/**
-	 * Unmasks a buffer using the given mask.
-	 *
-	 * @param {Buffer} buffer The buffer to unmask
-	 * @param {Buffer} mask The mask to use
-	 * @public
-	 */
-	function _unmask(buffer, mask) {
-	  for (let i = 0; i < buffer.length; i++) {
-	    buffer[i] ^= mask[i & 3];
-	  }
-	}
-
-	/**
-	 * Converts a buffer to an `ArrayBuffer`.
-	 *
-	 * @param {Buffer} buf The buffer to convert
-	 * @return {ArrayBuffer} Converted buffer
-	 * @public
-	 */
-	function toArrayBuffer(buf) {
-	  if (buf.length === buf.buffer.byteLength) {
-	    return buf.buffer;
-	  }
-
-	  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
-	}
-
-	/**
-	 * Converts `data` to a `Buffer`.
-	 *
-	 * @param {*} data The data to convert
-	 * @return {Buffer} The buffer
-	 * @throws {TypeError}
-	 * @public
-	 */
-	function toBuffer(data) {
-	  toBuffer.readOnly = true;
-
-	  if (Buffer.isBuffer(data)) return data;
-
-	  let buf;
-
-	  if (data instanceof ArrayBuffer) {
-	    buf = new FastBuffer(data);
-	  } else if (ArrayBuffer.isView(data)) {
-	    buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
-	  } else {
-	    buf = Buffer.from(data);
-	    toBuffer.readOnly = false;
-	  }
-
-	  return buf;
-	}
-
-	bufferUtil.exports = {
-	  concat,
-	  mask: _mask,
-	  toArrayBuffer,
-	  toBuffer,
-	  unmask: _unmask
-	};
-
-	/* istanbul ignore else  */
-	if (!process.env.WS_NO_BUFFER_UTIL) {
-	  try {
-	    const bufferUtil$1 = require('bufferutil');
-
-	    bufferUtil.exports.mask = function (source, mask, output, offset, length) {
-	      if (length < 48) _mask(source, mask, output, offset, length);
-	      else bufferUtil$1.mask(source, mask, output, offset, length);
-	    };
-
-	    bufferUtil.exports.unmask = function (buffer, mask) {
-	      if (buffer.length < 32) _unmask(buffer, mask);
-	      else bufferUtil$1.unmask(buffer, mask);
-	    };
-	  } catch (e) {
-	    // Continue regardless of the error.
-	  }
-	}
-	return bufferUtil.exports;
-}
-
-export { requireBufferUtil as __require };

package/dist/src/node_modules/engine.io-client/node_modules/ws/lib/constants.js

@@ -1,21 +0,0 @@
-var constants;
-var hasRequiredConstants;
-
-function requireConstants () {
-	if (hasRequiredConstants) return constants;
-	hasRequiredConstants = 1;
-
-	constants = {
-	  BINARY_TYPES: ['nodebuffer', 'arraybuffer', 'fragments'],
-	  EMPTY_BUFFER: Buffer.alloc(0),
-	  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
-	  kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),
-	  kListener: Symbol('kListener'),
-	  kStatusCode: Symbol('status-code'),
-	  kWebSocket: Symbol('websocket'),
-	  NOOP: () => {}
-	};
-	return constants;
-}
-
-export { requireConstants as __require };

package/dist/src/node_modules/engine.io-client/node_modules/ws/lib/event-target.js

@@ -1,303 +0,0 @@
-import { __require as requireConstants } from './constants.js';
-
-var eventTarget;
-var hasRequiredEventTarget;
-
-function requireEventTarget () {
-	if (hasRequiredEventTarget) return eventTarget;
-	hasRequiredEventTarget = 1;
-
-	const { kForOnEventAttribute, kListener } = requireConstants();
-
-	const kCode = Symbol('kCode');
-	const kData = Symbol('kData');
-	const kError = Symbol('kError');
-	const kMessage = Symbol('kMessage');
-	const kReason = Symbol('kReason');
-	const kTarget = Symbol('kTarget');
-	const kType = Symbol('kType');
-	const kWasClean = Symbol('kWasClean');
-
-	/**
-	 * Class representing an event.
-	 */
-	class Event {
-	  /**
-	   * Create a new `Event`.
-	   *
-	   * @param {String} type The name of the event
-	   * @throws {TypeError} If the `type` argument is not specified
-	   */
-	  constructor(type) {
-	    this[kTarget] = null;
-	    this[kType] = type;
-	  }
-
-	  /**
-	   * @type {*}
-	   */
-	  get target() {
-	    return this[kTarget];
-	  }
-
-	  /**
-	   * @type {String}
-	   */
-	  get type() {
-	    return this[kType];
-	  }
-	}
-
-	Object.defineProperty(Event.prototype, 'target', { enumerable: true });
-	Object.defineProperty(Event.prototype, 'type', { enumerable: true });
-
-	/**
-	 * Class representing a close event.
-	 *
-	 * @extends Event
-	 */
-	class CloseEvent extends Event {
-	  /**
-	   * Create a new `CloseEvent`.
-	   *
-	   * @param {String} type The name of the event
-	   * @param {Object} [options] A dictionary object that allows for setting
-	   *     attributes via object members of the same name
-	   * @param {Number} [options.code=0] The status code explaining why the
-	   *     connection was closed
-	   * @param {String} [options.reason=''] A human-readable string explaining why
-	   *     the connection was closed
-	   * @param {Boolean} [options.wasClean=false] Indicates whether or not the
-	   *     connection was cleanly closed
-	   */
-	  constructor(type, options = {}) {
-	    super(type);
-
-	    this[kCode] = options.code === undefined ? 0 : options.code;
-	    this[kReason] = options.reason === undefined ? '' : options.reason;
-	    this[kWasClean] = options.wasClean === undefined ? false : options.wasClean;
-	  }
-
-	  /**
-	   * @type {Number}
-	   */
-	  get code() {
-	    return this[kCode];
-	  }
-
-	  /**
-	   * @type {String}
-	   */
-	  get reason() {
-	    return this[kReason];
-	  }
-
-	  /**
-	   * @type {Boolean}
-	   */
-	  get wasClean() {
-	    return this[kWasClean];
-	  }
-	}
-
-	Object.defineProperty(CloseEvent.prototype, 'code', { enumerable: true });
-	Object.defineProperty(CloseEvent.prototype, 'reason', { enumerable: true });
-	Object.defineProperty(CloseEvent.prototype, 'wasClean', { enumerable: true });
-
-	/**
-	 * Class representing an error event.
-	 *
-	 * @extends Event
-	 */
-	class ErrorEvent extends Event {
-	  /**
-	   * Create a new `ErrorEvent`.
-	   *
-	   * @param {String} type The name of the event
-	   * @param {Object} [options] A dictionary object that allows for setting
-	   *     attributes via object members of the same name
-	   * @param {*} [options.error=null] The error that generated this event
-	   * @param {String} [options.message=''] The error message
-	   */
-	  constructor(type, options = {}) {
-	    super(type);
-
-	    this[kError] = options.error === undefined ? null : options.error;
-	    this[kMessage] = options.message === undefined ? '' : options.message;
-	  }
-
-	  /**
-	   * @type {*}
-	   */
-	  get error() {
-	    return this[kError];
-	  }
-
-	  /**
-	   * @type {String}
-	   */
-	  get message() {
-	    return this[kMessage];
-	  }
-	}
-
-	Object.defineProperty(ErrorEvent.prototype, 'error', { enumerable: true });
-	Object.defineProperty(ErrorEvent.prototype, 'message', { enumerable: true });
-
-	/**
-	 * Class representing a message event.
-	 *
-	 * @extends Event
-	 */
-	class MessageEvent extends Event {
-	  /**
-	   * Create a new `MessageEvent`.
-	   *
-	   * @param {String} type The name of the event
-	   * @param {Object} [options] A dictionary object that allows for setting
-	   *     attributes via object members of the same name
-	   * @param {*} [options.data=null] The message content
-	   */
-	  constructor(type, options = {}) {
-	    super(type);
-
-	    this[kData] = options.data === undefined ? null : options.data;
-	  }
-
-	  /**
-	   * @type {*}
-	   */
-	  get data() {
-	    return this[kData];
-	  }
-	}
-
-	Object.defineProperty(MessageEvent.prototype, 'data', { enumerable: true });
-
-	/**
-	 * This provides methods for emulating the `EventTarget` interface. It's not
-	 * meant to be used directly.
-	 *
-	 * @mixin
-	 */
-	const EventTarget = {
-	  /**
-	   * Register an event listener.
-	   *
-	   * @param {String} type A string representing the event type to listen for
-	   * @param {(Function|Object)} handler The listener to add
-	   * @param {Object} [options] An options object specifies characteristics about
-	   *     the event listener
-	   * @param {Boolean} [options.once=false] A `Boolean` indicating that the
-	   *     listener should be invoked at most once after being added. If `true`,
-	   *     the listener would be automatically removed when invoked.
-	   * @public
-	   */
-	  addEventListener(type, handler, options = {}) {
-	    for (const listener of this.listeners(type)) {
-	      if (
-	        !options[kForOnEventAttribute] &&
-	        listener[kListener] === handler &&
-	        !listener[kForOnEventAttribute]
-	      ) {
-	        return;
-	      }
-	    }
-
-	    let wrapper;
-
-	    if (type === 'message') {
-	      wrapper = function onMessage(data, isBinary) {
-	        const event = new MessageEvent('message', {
-	          data: isBinary ? data : data.toString()
-	        });
-
-	        event[kTarget] = this;
-	        callListener(handler, this, event);
-	      };
-	    } else if (type === 'close') {
-	      wrapper = function onClose(code, message) {
-	        const event = new CloseEvent('close', {
-	          code,
-	          reason: message.toString(),
-	          wasClean: this._closeFrameReceived && this._closeFrameSent
-	        });
-
-	        event[kTarget] = this;
-	        callListener(handler, this, event);
-	      };
-	    } else if (type === 'error') {
-	      wrapper = function onError(error) {
-	        const event = new ErrorEvent('error', {
-	          error,
-	          message: error.message
-	        });
-
-	        event[kTarget] = this;
-	        callListener(handler, this, event);
-	      };
-	    } else if (type === 'open') {
-	      wrapper = function onOpen() {
-	        const event = new Event('open');
-
-	        event[kTarget] = this;
-	        callListener(handler, this, event);
-	      };
-	    } else {
-	      return;
-	    }
-
-	    wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
-	    wrapper[kListener] = handler;
-
-	    if (options.once) {
-	      this.once(type, wrapper);
-	    } else {
-	      this.on(type, wrapper);
-	    }
-	  },
-
-	  /**
-	   * Remove an event listener.
-	   *
-	   * @param {String} type A string representing the event type to remove
-	   * @param {(Function|Object)} handler The listener to remove
-	   * @public
-	   */
-	  removeEventListener(type, handler) {
-	    for (const listener of this.listeners(type)) {
-	      if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
-	        this.removeListener(type, listener);
-	        break;
-	      }
-	    }
-	  }
-	};
-
-	eventTarget = {
-	  CloseEvent,
-	  ErrorEvent,
-	  Event,
-	  EventTarget,
-	  MessageEvent
-	};
-
-	/**
-	 * Call an event listener
-	 *
-	 * @param {(Function|Object)} listener The listener to call
-	 * @param {*} thisArg The value to use as `this`` when calling the listener
-	 * @param {Event} event The event to pass to the listener
-	 * @private
-	 */
-	function callListener(listener, thisArg, event) {
-	  if (typeof listener === 'object' && listener.handleEvent) {
-	    listener.handleEvent.call(listener, event);
-	  } else {
-	    listener.call(thisArg, event);
-	  }
-	}
-	return eventTarget;
-}
-
-export { requireEventTarget as __require };