@wabot-dev/framework 0.0.12 → 0.0.14

package/dist/src/node_modules/engine.io/node_modules/negotiator/lib/language.js

@@ -0,0 +1,188 @@
+import { __module as language } from '../../../../../_virtual/language2.js';
+
+/**
+ * negotiator
+ * Copyright(c) 2012 Isaac Z. Schlueter
+ * Copyright(c) 2014 Federico Romero
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredLanguage;
+
+function requireLanguage () {
+	if (hasRequiredLanguage) return language.exports;
+	hasRequiredLanguage = 1;
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	language.exports = preferredLanguages;
+	language.exports.preferredLanguages = preferredLanguages;
+
+	/**
+	 * Module variables.
+	 * @private
+	 */
+
+	var simpleLanguageRegExp = /^\s*([^\s\-;]+)(?:-([^\s;]+))?\s*(?:;(.*))?$/;
+
+	/**
+	 * Parse the Accept-Language header.
+	 * @private
+	 */
+
+	function parseAcceptLanguage(accept) {
+	  var accepts = accept.split(',');
+
+	  for (var i = 0, j = 0; i < accepts.length; i++) {
+	    var language = parseLanguage(accepts[i].trim(), i);
+
+	    if (language) {
+	      accepts[j++] = language;
+	    }
+	  }
+
+	  // trim accepts
+	  accepts.length = j;
+
+	  return accepts;
+	}
+
+	/**
+	 * Parse a language from the Accept-Language header.
+	 * @private
+	 */
+
+	function parseLanguage(str, i) {
+	  var match = simpleLanguageRegExp.exec(str);
+	  if (!match) return null;
+
+	  var prefix = match[1];
+	  var suffix = match[2];
+	  var full = prefix;
+
+	  if (suffix) full += "-" + suffix;
+
+	  var q = 1;
+	  if (match[3]) {
+	    var params = match[3].split(';');
+	    for (var j = 0; j < params.length; j++) {
+	      var p = params[j].split('=');
+	      if (p[0] === 'q') q = parseFloat(p[1]);
+	    }
+	  }
+
+	  return {
+	    prefix: prefix,
+	    suffix: suffix,
+	    q: q,
+	    i: i,
+	    full: full
+	  };
+	}
+
+	/**
+	 * Get the priority of a language.
+	 * @private
+	 */
+
+	function getLanguagePriority(language, accepted, index) {
+	  var priority = {o: -1, q: 0, s: 0};
+
+	  for (var i = 0; i < accepted.length; i++) {
+	    var spec = specify(language, accepted[i], index);
+
+	    if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
+	      priority = spec;
+	    }
+	  }
+
+	  return priority;
+	}
+
+	/**
+	 * Get the specificity of the language.
+	 * @private
+	 */
+
+	function specify(language, spec, index) {
+	  var p = parseLanguage(language);
+	  if (!p) return null;
+	  var s = 0;
+	  if(spec.full.toLowerCase() === p.full.toLowerCase()){
+	    s |= 4;
+	  } else if (spec.prefix.toLowerCase() === p.full.toLowerCase()) {
+	    s |= 2;
+	  } else if (spec.full.toLowerCase() === p.prefix.toLowerCase()) {
+	    s |= 1;
+	  } else if (spec.full !== '*' ) {
+	    return null
+	  }
+
+	  return {
+	    i: index,
+	    o: spec.i,
+	    q: spec.q,
+	    s: s
+	  }
+	}
+	/**
+	 * Get the preferred languages from an Accept-Language header.
+	 * @public
+	 */
+
+	function preferredLanguages(accept, provided) {
+	  // RFC 2616 sec 14.4: no header = *
+	  var accepts = parseAcceptLanguage(accept === undefined ? '*' : accept || '');
+
+	  if (!provided) {
+	    // sorted list of all languages
+	    return accepts
+	      .filter(isQuality)
+	      .sort(compareSpecs)
+	      .map(getFullLanguage);
+	  }
+
+	  var priorities = provided.map(function getPriority(type, index) {
+	    return getLanguagePriority(type, accepts, index);
+	  });
+
+	  // sorted list of accepted languages
+	  return priorities.filter(isQuality).sort(compareSpecs).map(function getLanguage(priority) {
+	    return provided[priorities.indexOf(priority)];
+	  });
+	}
+
+	/**
+	 * Compare two specs.
+	 * @private
+	 */
+
+	function compareSpecs(a, b) {
+	  return (b.q - a.q) || (b.s - a.s) || (a.o - b.o) || (a.i - b.i) || 0;
+	}
+
+	/**
+	 * Get full language string.
+	 * @private
+	 */
+
+	function getFullLanguage(spec) {
+	  return spec.full;
+	}
+
+	/**
+	 * Check if a spec has any quality.
+	 * @private
+	 */
+
+	function isQuality(spec) {
+	  return spec.q > 0;
+	}
+	return language.exports;
+}
+
+export { requireLanguage as __require };

package/dist/src/node_modules/engine.io/node_modules/negotiator/lib/mediaType.js

@@ -0,0 +1,304 @@
+import { __module as mediaType } from '../../../../../_virtual/mediaType2.js';
+
+/**
+ * negotiator
+ * Copyright(c) 2012 Isaac Z. Schlueter
+ * Copyright(c) 2014 Federico Romero
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredMediaType;
+
+function requireMediaType () {
+	if (hasRequiredMediaType) return mediaType.exports;
+	hasRequiredMediaType = 1;
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	mediaType.exports = preferredMediaTypes;
+	mediaType.exports.preferredMediaTypes = preferredMediaTypes;
+
+	/**
+	 * Module variables.
+	 * @private
+	 */
+
+	var simpleMediaTypeRegExp = /^\s*([^\s\/;]+)\/([^;\s]+)\s*(?:;(.*))?$/;
+
+	/**
+	 * Parse the Accept header.
+	 * @private
+	 */
+
+	function parseAccept(accept) {
+	  var accepts = splitMediaTypes(accept);
+
+	  for (var i = 0, j = 0; i < accepts.length; i++) {
+	    var mediaType = parseMediaType(accepts[i].trim(), i);
+
+	    if (mediaType) {
+	      accepts[j++] = mediaType;
+	    }
+	  }
+
+	  // trim accepts
+	  accepts.length = j;
+
+	  return accepts;
+	}
+
+	/**
+	 * Parse a media type from the Accept header.
+	 * @private
+	 */
+
+	function parseMediaType(str, i) {
+	  var match = simpleMediaTypeRegExp.exec(str);
+	  if (!match) return null;
+
+	  var params = Object.create(null);
+	  var q = 1;
+	  var subtype = match[2];
+	  var type = match[1];
+
+	  if (match[3]) {
+	    var kvps = splitParameters(match[3]).map(splitKeyValuePair);
+
+	    for (var j = 0; j < kvps.length; j++) {
+	      var pair = kvps[j];
+	      var key = pair[0].toLowerCase();
+	      var val = pair[1];
+
+	      // get the value, unwrapping quotes
+	      var value = val && val[0] === '"' && val[val.length - 1] === '"'
+	        ? val.substr(1, val.length - 2)
+	        : val;
+
+	      if (key === 'q') {
+	        q = parseFloat(value);
+	        break;
+	      }
+
+	      // store parameter
+	      params[key] = value;
+	    }
+	  }
+
+	  return {
+	    type: type,
+	    subtype: subtype,
+	    params: params,
+	    q: q,
+	    i: i
+	  };
+	}
+
+	/**
+	 * Get the priority of a media type.
+	 * @private
+	 */
+
+	function getMediaTypePriority(type, accepted, index) {
+	  var priority = {o: -1, q: 0, s: 0};
+
+	  for (var i = 0; i < accepted.length; i++) {
+	    var spec = specify(type, accepted[i], index);
+
+	    if (spec && (priority.s - spec.s || priority.q - spec.q || priority.o - spec.o) < 0) {
+	      priority = spec;
+	    }
+	  }
+
+	  return priority;
+	}
+
+	/**
+	 * Get the specificity of the media type.
+	 * @private
+	 */
+
+	function specify(type, spec, index) {
+	  var p = parseMediaType(type);
+	  var s = 0;
+
+	  if (!p) {
+	    return null;
+	  }
+
+	  if(spec.type.toLowerCase() == p.type.toLowerCase()) {
+	    s |= 4;
+	  } else if(spec.type != '*') {
+	    return null;
+	  }
+
+	  if(spec.subtype.toLowerCase() == p.subtype.toLowerCase()) {
+	    s |= 2;
+	  } else if(spec.subtype != '*') {
+	    return null;
+	  }
+
+	  var keys = Object.keys(spec.params);
+	  if (keys.length > 0) {
+	    if (keys.every(function (k) {
+	      return spec.params[k] == '*' || (spec.params[k] || '').toLowerCase() == (p.params[k] || '').toLowerCase();
+	    })) {
+	      s |= 1;
+	    } else {
+	      return null
+	    }
+	  }
+
+	  return {
+	    i: index,
+	    o: spec.i,
+	    q: spec.q,
+	    s: s,
+	  }
+	}
+
+	/**
+	 * Get the preferred media types from an Accept header.
+	 * @public
+	 */
+
+	function preferredMediaTypes(accept, provided) {
+	  // RFC 2616 sec 14.2: no header = */*
+	  var accepts = parseAccept(accept === undefined ? '*/*' : accept || '');
+
+	  if (!provided) {
+	    // sorted list of all types
+	    return accepts
+	      .filter(isQuality)
+	      .sort(compareSpecs)
+	      .map(getFullType);
+	  }
+
+	  var priorities = provided.map(function getPriority(type, index) {
+	    return getMediaTypePriority(type, accepts, index);
+	  });
+
+	  // sorted list of accepted types
+	  return priorities.filter(isQuality).sort(compareSpecs).map(function getType(priority) {
+	    return provided[priorities.indexOf(priority)];
+	  });
+	}
+
+	/**
+	 * Compare two specs.
+	 * @private
+	 */
+
+	function compareSpecs(a, b) {
+	  return (b.q - a.q) || (b.s - a.s) || (a.o - b.o) || (a.i - b.i) || 0;
+	}
+
+	/**
+	 * Get full type string.
+	 * @private
+	 */
+
+	function getFullType(spec) {
+	  return spec.type + '/' + spec.subtype;
+	}
+
+	/**
+	 * Check if a spec has any quality.
+	 * @private
+	 */
+
+	function isQuality(spec) {
+	  return spec.q > 0;
+	}
+
+	/**
+	 * Count the number of quotes in a string.
+	 * @private
+	 */
+
+	function quoteCount(string) {
+	  var count = 0;
+	  var index = 0;
+
+	  while ((index = string.indexOf('"', index)) !== -1) {
+	    count++;
+	    index++;
+	  }
+
+	  return count;
+	}
+
+	/**
+	 * Split a key value pair.
+	 * @private
+	 */
+
+	function splitKeyValuePair(str) {
+	  var index = str.indexOf('=');
+	  var key;
+	  var val;
+
+	  if (index === -1) {
+	    key = str;
+	  } else {
+	    key = str.substr(0, index);
+	    val = str.substr(index + 1);
+	  }
+
+	  return [key, val];
+	}
+
+	/**
+	 * Split an Accept header into media types.
+	 * @private
+	 */
+
+	function splitMediaTypes(accept) {
+	  var accepts = accept.split(',');
+
+	  for (var i = 1, j = 0; i < accepts.length; i++) {
+	    if (quoteCount(accepts[j]) % 2 == 0) {
+	      accepts[++j] = accepts[i];
+	    } else {
+	      accepts[j] += ',' + accepts[i];
+	    }
+	  }
+
+	  // trim accepts
+	  accepts.length = j + 1;
+
+	  return accepts;
+	}
+
+	/**
+	 * Split a string of parameters.
+	 * @private
+	 */
+
+	function splitParameters(str) {
+	  var parameters = str.split(';');
+
+	  for (var i = 1, j = 0; i < parameters.length; i++) {
+	    if (quoteCount(parameters[j]) % 2 == 0) {
+	      parameters[++j] = parameters[i];
+	    } else {
+	      parameters[j] += ';' + parameters[i];
+	    }
+	  }
+
+	  // trim parameters
+	  parameters.length = j + 1;
+
+	  for (var i = 0; i < parameters.length; i++) {
+	    parameters[i] = parameters[i].trim();
+	  }
+
+	  return parameters;
+	}
+	return mediaType.exports;
+}
+
+export { requireMediaType as __require };

package/dist/src/node_modules/engine.io/node_modules/ws/index.js

@@ -0,0 +1,28 @@
+import { __require as requireWebsocket } from './lib/websocket.js';
+import { __require as requireStream } from './lib/stream.js';
+import { __require as requireWebsocketServer } from './lib/websocket-server.js';
+import { __require as requireReceiver } from './lib/receiver.js';
+import { __require as requireSender } from './lib/sender.js';
+
+var ws;
+var hasRequiredWs;
+
+function requireWs () {
+	if (hasRequiredWs) return ws;
+	hasRequiredWs = 1;
+
+	const WebSocket = requireWebsocket();
+
+	WebSocket.createWebSocketStream = requireStream();
+	WebSocket.Server = requireWebsocketServer();
+	WebSocket.Receiver = requireReceiver();
+	WebSocket.Sender = requireSender();
+
+	WebSocket.WebSocket = WebSocket;
+	WebSocket.WebSocketServer = WebSocket.Server;
+
+	ws = WebSocket;
+	return ws;
+}
+
+export { requireWs as __require };

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

@@ -0,0 +1,142 @@
+import { __module as bufferUtil } from '../../../../../_virtual/buffer-util2.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/node_modules/ws/lib/constants.js

@@ -0,0 +1,21 @@
+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 };