@wabot-dev/framework 0.0.12 → 0.0.14

package/dist/src/node_modules/@socket.io/component-emitter/lib/esm/index.js

@@ -0,0 +1,171 @@
+/**
+ * Initialize a new `Emitter`.
+ *
+ * @api public
+ */
+
+function Emitter(obj) {
+  if (obj) return mixin(obj);
+}
+
+/**
+ * Mixin the emitter properties.
+ *
+ * @param {Object} obj
+ * @return {Object}
+ * @api private
+ */
+
+function mixin(obj) {
+  for (var key in Emitter.prototype) {
+    obj[key] = Emitter.prototype[key];
+  }
+  return obj;
+}
+
+/**
+ * Listen on the given `event` with `fn`.
+ *
+ * @param {String} event
+ * @param {Function} fn
+ * @return {Emitter}
+ * @api public
+ */
+
+Emitter.prototype.on =
+Emitter.prototype.addEventListener = function(event, fn){
+  this._callbacks = this._callbacks || {};
+  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])
+    .push(fn);
+  return this;
+};
+
+/**
+ * Adds an `event` listener that will be invoked a single
+ * time then automatically removed.
+ *
+ * @param {String} event
+ * @param {Function} fn
+ * @return {Emitter}
+ * @api public
+ */
+
+Emitter.prototype.once = function(event, fn){
+  function on() {
+    this.off(event, on);
+    fn.apply(this, arguments);
+  }
+
+  on.fn = fn;
+  this.on(event, on);
+  return this;
+};
+
+/**
+ * Remove the given callback for `event` or all
+ * registered callbacks.
+ *
+ * @param {String} event
+ * @param {Function} fn
+ * @return {Emitter}
+ * @api public
+ */
+
+Emitter.prototype.off =
+Emitter.prototype.removeListener =
+Emitter.prototype.removeAllListeners =
+Emitter.prototype.removeEventListener = function(event, fn){
+  this._callbacks = this._callbacks || {};
+
+  // all
+  if (0 == arguments.length) {
+    this._callbacks = {};
+    return this;
+  }
+
+  // specific event
+  var callbacks = this._callbacks['$' + event];
+  if (!callbacks) return this;
+
+  // remove all handlers
+  if (1 == arguments.length) {
+    delete this._callbacks['$' + event];
+    return this;
+  }
+
+  // remove specific handler
+  var cb;
+  for (var i = 0; i < callbacks.length; i++) {
+    cb = callbacks[i];
+    if (cb === fn || cb.fn === fn) {
+      callbacks.splice(i, 1);
+      break;
+    }
+  }
+
+  // Remove event specific arrays for event types that no
+  // one is subscribed for to avoid memory leak.
+  if (callbacks.length === 0) {
+    delete this._callbacks['$' + event];
+  }
+
+  return this;
+};
+
+/**
+ * Emit `event` with the given args.
+ *
+ * @param {String} event
+ * @param {Mixed} ...
+ * @return {Emitter}
+ */
+
+Emitter.prototype.emit = function(event){
+  this._callbacks = this._callbacks || {};
+
+  var args = new Array(arguments.length - 1)
+    , callbacks = this._callbacks['$' + event];
+
+  for (var i = 1; i < arguments.length; i++) {
+    args[i - 1] = arguments[i];
+  }
+
+  if (callbacks) {
+    callbacks = callbacks.slice(0);
+    for (var i = 0, len = callbacks.length; i < len; ++i) {
+      callbacks[i].apply(this, args);
+    }
+  }
+
+  return this;
+};
+
+// alias used for reserved events (protected method)
+Emitter.prototype.emitReserved = Emitter.prototype.emit;
+
+/**
+ * Return array of callbacks for `event`.
+ *
+ * @param {String} event
+ * @return {Array}
+ * @api public
+ */
+
+Emitter.prototype.listeners = function(event){
+  this._callbacks = this._callbacks || {};
+  return this._callbacks['$' + event] || [];
+};
+
+/**
+ * Check if this emitter has `event` handlers.
+ *
+ * @param {String} event
+ * @return {Boolean}
+ * @api public
+ */
+
+Emitter.prototype.hasListeners = function(event){
+  return !! this.listeners(event).length;
+};
+
+export { Emitter };

package/dist/src/node_modules/base64id/lib/base64id.js

@@ -0,0 +1,117 @@
+import { __module as base64id } from '../../../_virtual/base64id.js';
+import require$$1 from 'crypto';
+
+/*!
+ * base64id v0.1.0
+ */
+
+var hasRequiredBase64id;
+
+function requireBase64id () {
+	if (hasRequiredBase64id) return base64id.exports;
+	hasRequiredBase64id = 1;
+	(function (module, exports) {
+		/**
+		 * Module dependencies
+		 */
+
+		var crypto = require$$1;
+
+		/**
+		 * Constructor
+		 */
+
+		var Base64Id = function() { };
+
+		/**
+		 * Get random bytes
+		 *
+		 * Uses a buffer if available, falls back to crypto.randomBytes
+		 */
+
+		Base64Id.prototype.getRandomBytes = function(bytes) {
+
+		  var BUFFER_SIZE = 4096;
+		  var self = this;  
+		  
+		  bytes = bytes || 12;
+
+		  if (bytes > BUFFER_SIZE) {
+		    return crypto.randomBytes(bytes);
+		  }
+		  
+		  var bytesInBuffer = parseInt(BUFFER_SIZE/bytes);
+		  var threshold = parseInt(bytesInBuffer*0.85);
+
+		  if (!threshold) {
+		    return crypto.randomBytes(bytes);
+		  }
+
+		  if (this.bytesBufferIndex == null) {
+		     this.bytesBufferIndex = -1;
+		  }
+
+		  if (this.bytesBufferIndex == bytesInBuffer) {
+		    this.bytesBuffer = null;
+		    this.bytesBufferIndex = -1;
+		  }
+
+		  // No buffered bytes available or index above threshold
+		  if (this.bytesBufferIndex == -1 || this.bytesBufferIndex > threshold) {
+		     
+		    if (!this.isGeneratingBytes) {
+		      this.isGeneratingBytes = true;
+		      crypto.randomBytes(BUFFER_SIZE, function(err, bytes) {
+		        self.bytesBuffer = bytes;
+		        self.bytesBufferIndex = 0;
+		        self.isGeneratingBytes = false;
+		      }); 
+		    }
+		    
+		    // Fall back to sync call when no buffered bytes are available
+		    if (this.bytesBufferIndex == -1) {
+		      return crypto.randomBytes(bytes);
+		    }
+		  }
+		  
+		  var result = this.bytesBuffer.slice(bytes*this.bytesBufferIndex, bytes*(this.bytesBufferIndex+1)); 
+		  this.bytesBufferIndex++; 
+		  
+		  return result;
+		};
+
+		/**
+		 * Generates a base64 id
+		 *
+		 * (Original version from socket.io <http://socket.io>)
+		 */
+
+		Base64Id.prototype.generateId = function () {
+		  var rand = Buffer.alloc(15); // multiple of 3 for base64
+		  if (!rand.writeInt32BE) {
+		    return Math.abs(Math.random() * Math.random() * Date.now() | 0).toString()
+		      + Math.abs(Math.random() * Math.random() * Date.now() | 0).toString();
+		  }
+		  this.sequenceNumber = (this.sequenceNumber + 1) | 0;
+		  rand.writeInt32BE(this.sequenceNumber, 11);
+		  if (crypto.randomBytes) {
+		    this.getRandomBytes(12).copy(rand);
+		  } else {
+		    // not secure for node 0.4
+		    [0, 4, 8].forEach(function(i) {
+		      rand.writeInt32BE(Math.random() * Math.pow(2, 32) | 0, i);
+		    });
+		  }
+		  return rand.toString('base64').replace(/\//g, '_').replace(/\+/g, '-');
+		};
+
+		/**
+		 * Export
+		 */
+
+		module.exports = new Base64Id(); 
+	} (base64id));
+	return base64id.exports;
+}
+
+export { requireBase64id as __require };

package/dist/src/node_modules/body-parser/index.js

@@ -0,0 +1,96 @@
+import { __module as bodyParser } from '../../_virtual/index4.js';
+import { __require as requireJson } from './lib/types/json.js';
+import { __require as requireRaw } from './lib/types/raw.js';
+import { __require as requireText } from './lib/types/text.js';
+import { __require as requireUrlencoded } from './lib/types/urlencoded.js';
+
+/*!
+ * body-parser
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredBodyParser;
+
+function requireBodyParser () {
+	if (hasRequiredBodyParser) return bodyParser.exports;
+	hasRequiredBodyParser = 1;
+	(function (module, exports) {
+
+		/**
+		 * @typedef Parsers
+		 * @type {function}
+		 * @property {function} json
+		 * @property {function} raw
+		 * @property {function} text
+		 * @property {function} urlencoded
+		 */
+
+		/**
+		 * Module exports.
+		 * @type {Parsers}
+		 */
+
+		exports = module.exports = bodyParser;
+
+		/**
+		 * JSON parser.
+		 * @public
+		 */
+
+		Object.defineProperty(exports, 'json', {
+		  configurable: true,
+		  enumerable: true,
+		  get: () => requireJson()
+		});
+
+		/**
+		 * Raw parser.
+		 * @public
+		 */
+
+		Object.defineProperty(exports, 'raw', {
+		  configurable: true,
+		  enumerable: true,
+		  get: () => requireRaw()
+		});
+
+		/**
+		 * Text parser.
+		 * @public
+		 */
+
+		Object.defineProperty(exports, 'text', {
+		  configurable: true,
+		  enumerable: true,
+		  get: () => requireText()
+		});
+
+		/**
+		 * URL-encoded parser.
+		 * @public
+		 */
+
+		Object.defineProperty(exports, 'urlencoded', {
+		  configurable: true,
+		  enumerable: true,
+		  get: () => requireUrlencoded()
+		});
+
+		/**
+		 * Create a middleware to parse json and urlencoded bodies.
+		 *
+		 * @param {object} [options]
+		 * @return {function}
+		 * @deprecated
+		 * @public
+		 */
+
+		function bodyParser () {
+		  throw new Error('The bodyParser() generic has been split into individual middleware to use instead.')
+		} 
+	} (bodyParser, bodyParser.exports));
+	return bodyParser.exports;
+}
+
+export { requireBodyParser as __require };

package/dist/src/node_modules/body-parser/lib/read.js

@@ -0,0 +1,225 @@
+import { __require as requireHttpErrors } from '../../http-errors/index.js';
+import { __require as requireRawBody } from '../../raw-body/index.js';
+import { __require as requireLib } from '../../iconv-lite/lib/index.js';
+import { __require as requireOnFinished } from '../../on-finished/index.js';
+import require$$4 from 'node:zlib';
+
+/*!
+ * body-parser
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var read_1;
+var hasRequiredRead;
+
+function requireRead () {
+	if (hasRequiredRead) return read_1;
+	hasRequiredRead = 1;
+
+	/**
+	 * Module dependencies.
+	 * @private
+	 */
+
+	var createError = requireHttpErrors();
+	var getBody = requireRawBody();
+	var iconv = requireLib();
+	var onFinished = requireOnFinished();
+	var zlib = require$$4;
+
+	/**
+	 * Module exports.
+	 */
+
+	read_1 = read;
+
+	/**
+	 * Read a request into a buffer and parse.
+	 *
+	 * @param {object} req
+	 * @param {object} res
+	 * @param {function} next
+	 * @param {function} parse
+	 * @param {function} debug
+	 * @param {object} options
+	 * @private
+	 */
+
+	function read (req, res, next, parse, debug, options) {
+	  var length;
+	  var opts = options;
+	  var stream;
+
+	  // read options
+	  var encoding = opts.encoding !== null
+	    ? opts.encoding
+	    : null;
+	  var verify = opts.verify;
+
+	  try {
+	    // get the content stream
+	    stream = contentstream(req, debug, opts.inflate);
+	    length = stream.length;
+	    stream.length = undefined;
+	  } catch (err) {
+	    return next(err)
+	  }
+
+	  // set raw-body options
+	  opts.length = length;
+	  opts.encoding = verify
+	    ? null
+	    : encoding;
+
+	  // assert charset is supported
+	  if (opts.encoding === null && encoding !== null && !iconv.encodingExists(encoding)) {
+	    return next(createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', {
+	      charset: encoding.toLowerCase(),
+	      type: 'charset.unsupported'
+	    }))
+	  }
+
+	  // read body
+	  debug('read body');
+	  getBody(stream, opts, function (error, body) {
+	    if (error) {
+	      var _error;
+
+	      if (error.type === 'encoding.unsupported') {
+	        // echo back charset
+	        _error = createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', {
+	          charset: encoding.toLowerCase(),
+	          type: 'charset.unsupported'
+	        });
+	      } else {
+	        // set status code on error
+	        _error = createError(400, error);
+	      }
+
+	      // unpipe from stream and destroy
+	      if (stream !== req) {
+	        req.unpipe();
+	        stream.destroy();
+	      }
+
+	      // read off entire request
+	      dump(req, function onfinished () {
+	        next(createError(400, _error));
+	      });
+	      return
+	    }
+
+	    // verify
+	    if (verify) {
+	      try {
+	        debug('verify body');
+	        verify(req, res, body, encoding);
+	      } catch (err) {
+	        next(createError(403, err, {
+	          body: body,
+	          type: err.type || 'entity.verify.failed'
+	        }));
+	        return
+	      }
+	    }
+
+	    // parse
+	    var str = body;
+	    try {
+	      debug('parse body');
+	      str = typeof body !== 'string' && encoding !== null
+	        ? iconv.decode(body, encoding)
+	        : body;
+	      req.body = parse(str, encoding);
+	    } catch (err) {
+	      next(createError(400, err, {
+	        body: str,
+	        type: err.type || 'entity.parse.failed'
+	      }));
+	      return
+	    }
+
+	    next();
+	  });
+	}
+
+	/**
+	 * Get the content stream of the request.
+	 *
+	 * @param {object} req
+	 * @param {function} debug
+	 * @param {boolean} [inflate=true]
+	 * @return {object}
+	 * @api private
+	 */
+
+	function contentstream (req, debug, inflate) {
+	  var encoding = (req.headers['content-encoding'] || 'identity').toLowerCase();
+	  var length = req.headers['content-length'];
+
+	  debug('content-encoding "%s"', encoding);
+
+	  if (inflate === false && encoding !== 'identity') {
+	    throw createError(415, 'content encoding unsupported', {
+	      encoding: encoding,
+	      type: 'encoding.unsupported'
+	    })
+	  }
+
+	  if (encoding === 'identity') {
+	    req.length = length;
+	    return req
+	  }
+
+	  var stream = createDecompressionStream(encoding, debug);
+	  req.pipe(stream);
+	  return stream
+	}
+
+	/**
+	 * Create a decompression stream for the given encoding.
+	 * @param {string} encoding
+	 * @param {function} debug
+	 * @return {object}
+	 * @api private
+	 */
+	function createDecompressionStream (encoding, debug) {
+	  switch (encoding) {
+	    case 'deflate':
+	      debug('inflate body');
+	      return zlib.createInflate()
+	    case 'gzip':
+	      debug('gunzip body');
+	      return zlib.createGunzip()
+	    case 'br':
+	      debug('brotli decompress body');
+	      return zlib.createBrotliDecompress()
+	    default:
+	      throw createError(415, 'unsupported content encoding "' + encoding + '"', {
+	        encoding: encoding,
+	        type: 'encoding.unsupported'
+	      })
+	  }
+	}
+
+	/**
+	 * Dump the contents of a request.
+	 *
+	 * @param {object} req
+	 * @param {function} callback
+	 * @api private
+	 */
+
+	function dump (req, callback) {
+	  if (onFinished.isFinished(req)) {
+	    callback(null);
+	  } else {
+	    onFinished(req, callback);
+	    req.resume();
+	  }
+	}
+	return read_1;
+}
+
+export { requireRead as __require };