@wabot-dev/framework 0.0.12 → 0.0.14

package/dist/src/node_modules/engine.io/node_modules/mime-db/index.js

@@ -0,0 +1,24 @@
+import require$$0 from './db.json.js';
+
+/*!
+ * mime-db
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015-2022 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var mimeDb;
+var hasRequiredMimeDb;
+
+function requireMimeDb () {
+	if (hasRequiredMimeDb) return mimeDb;
+	hasRequiredMimeDb = 1;
+	/**
+	 * Module exports.
+	 */
+
+	mimeDb = require$$0;
+	return mimeDb;
+}
+
+export { requireMimeDb as __require };

package/dist/src/node_modules/engine.io/node_modules/mime-types/index.js

@@ -0,0 +1,202 @@
+import { __exports as mimeTypes } from '../../../../_virtual/index32.js';
+import { __require as requireMimeDb } from '../mime-db/index.js';
+import path from 'path';
+
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredMimeTypes;
+
+function requireMimeTypes () {
+	if (hasRequiredMimeTypes) return mimeTypes;
+	hasRequiredMimeTypes = 1;
+	(function (exports) {
+
+		/**
+		 * Module dependencies.
+		 * @private
+		 */
+
+		var db = requireMimeDb();
+		var extname = path.extname;
+
+		/**
+		 * Module variables.
+		 * @private
+		 */
+
+		var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
+		var TEXT_TYPE_REGEXP = /^text\//i;
+
+		/**
+		 * Module exports.
+		 * @public
+		 */
+
+		exports.charset = charset;
+		exports.charsets = { lookup: charset };
+		exports.contentType = contentType;
+		exports.extension = extension;
+		exports.extensions = Object.create(null);
+		exports.lookup = lookup;
+		exports.types = Object.create(null);
+
+		// Populate the extensions/types maps
+		populateMaps(exports.extensions, exports.types);
+
+		/**
+		 * Get the default charset for a MIME type.
+		 *
+		 * @param {string} type
+		 * @return {boolean|string}
+		 */
+
+		function charset (type) {
+		  if (!type || typeof type !== 'string') {
+		    return false
+		  }
+
+		  // TODO: use media-typer
+		  var match = EXTRACT_TYPE_REGEXP.exec(type);
+		  var mime = match && db[match[1].toLowerCase()];
+
+		  if (mime && mime.charset) {
+		    return mime.charset
+		  }
+
+		  // default text/* to utf-8
+		  if (match && TEXT_TYPE_REGEXP.test(match[1])) {
+		    return 'UTF-8'
+		  }
+
+		  return false
+		}
+
+		/**
+		 * Create a full Content-Type header given a MIME type or extension.
+		 *
+		 * @param {string} str
+		 * @return {boolean|string}
+		 */
+
+		function contentType (str) {
+		  // TODO: should this even be in this module?
+		  if (!str || typeof str !== 'string') {
+		    return false
+		  }
+
+		  var mime = str.indexOf('/') === -1
+		    ? exports.lookup(str)
+		    : str;
+
+		  if (!mime) {
+		    return false
+		  }
+
+		  // TODO: use content-type or other module
+		  if (mime.indexOf('charset') === -1) {
+		    var charset = exports.charset(mime);
+		    if (charset) mime += '; charset=' + charset.toLowerCase();
+		  }
+
+		  return mime
+		}
+
+		/**
+		 * Get the default extension for a MIME type.
+		 *
+		 * @param {string} type
+		 * @return {boolean|string}
+		 */
+
+		function extension (type) {
+		  if (!type || typeof type !== 'string') {
+		    return false
+		  }
+
+		  // TODO: use media-typer
+		  var match = EXTRACT_TYPE_REGEXP.exec(type);
+
+		  // get extensions
+		  var exts = match && exports.extensions[match[1].toLowerCase()];
+
+		  if (!exts || !exts.length) {
+		    return false
+		  }
+
+		  return exts[0]
+		}
+
+		/**
+		 * Lookup the MIME type for a file path/extension.
+		 *
+		 * @param {string} path
+		 * @return {boolean|string}
+		 */
+
+		function lookup (path) {
+		  if (!path || typeof path !== 'string') {
+		    return false
+		  }
+
+		  // get the extension ("ext" or ".ext" or full path)
+		  var extension = extname('x.' + path)
+		    .toLowerCase()
+		    .substr(1);
+
+		  if (!extension) {
+		    return false
+		  }
+
+		  return exports.types[extension] || false
+		}
+
+		/**
+		 * Populate the extensions and types maps.
+		 * @private
+		 */
+
+		function populateMaps (extensions, types) {
+		  // source preference (least -> most)
+		  var preference = ['nginx', 'apache', undefined, 'iana'];
+
+		  Object.keys(db).forEach(function forEachMimeType (type) {
+		    var mime = db[type];
+		    var exts = mime.extensions;
+
+		    if (!exts || !exts.length) {
+		      return
+		    }
+
+		    // mime -> extensions
+		    extensions[type] = exts;
+
+		    // extension -> mime
+		    for (var i = 0; i < exts.length; i++) {
+		      var extension = exts[i];
+
+		      if (types[extension]) {
+		        var from = preference.indexOf(db[types[extension]].source);
+		        var to = preference.indexOf(mime.source);
+
+		        if (types[extension] !== 'application/octet-stream' &&
+		          (from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
+		          // skip the remapping
+		          continue
+		        }
+		      }
+
+		      // set the extension -> mime
+		      types[extension] = type;
+		    }
+		  });
+		} 
+	} (mimeTypes));
+	return mimeTypes;
+}
+
+export { requireMimeTypes as __require };

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

@@ -0,0 +1,96 @@
+import { __module as negotiator } from '../../../../_virtual/index33.js';
+import { __require as requireCharset } from './lib/charset.js';
+import { __require as requireEncoding } from './lib/encoding.js';
+import { __require as requireLanguage } from './lib/language.js';
+import { __require as requireMediaType } from './lib/mediaType.js';
+
+/*!
+ * negotiator
+ * Copyright(c) 2012 Federico Romero
+ * Copyright(c) 2012-2014 Isaac Z. Schlueter
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredNegotiator;
+
+function requireNegotiator () {
+	if (hasRequiredNegotiator) return negotiator.exports;
+	hasRequiredNegotiator = 1;
+
+	var preferredCharsets = requireCharset();
+	var preferredEncodings = requireEncoding();
+	var preferredLanguages = requireLanguage();
+	var preferredMediaTypes = requireMediaType();
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	negotiator.exports = Negotiator;
+	negotiator.exports.Negotiator = Negotiator;
+
+	/**
+	 * Create a Negotiator instance from a request.
+	 * @param {object} request
+	 * @public
+	 */
+
+	function Negotiator(request) {
+	  if (!(this instanceof Negotiator)) {
+	    return new Negotiator(request);
+	  }
+
+	  this.request = request;
+	}
+
+	Negotiator.prototype.charset = function charset(available) {
+	  var set = this.charsets(available);
+	  return set && set[0];
+	};
+
+	Negotiator.prototype.charsets = function charsets(available) {
+	  return preferredCharsets(this.request.headers['accept-charset'], available);
+	};
+
+	Negotiator.prototype.encoding = function encoding(available) {
+	  var set = this.encodings(available);
+	  return set && set[0];
+	};
+
+	Negotiator.prototype.encodings = function encodings(available) {
+	  return preferredEncodings(this.request.headers['accept-encoding'], available);
+	};
+
+	Negotiator.prototype.language = function language(available) {
+	  var set = this.languages(available);
+	  return set && set[0];
+	};
+
+	Negotiator.prototype.languages = function languages(available) {
+	  return preferredLanguages(this.request.headers['accept-language'], available);
+	};
+
+	Negotiator.prototype.mediaType = function mediaType(available) {
+	  var set = this.mediaTypes(available);
+	  return set && set[0];
+	};
+
+	Negotiator.prototype.mediaTypes = function mediaTypes(available) {
+	  return preferredMediaTypes(this.request.headers.accept, available);
+	};
+
+	// Backwards compatibility
+	Negotiator.prototype.preferredCharset = Negotiator.prototype.charset;
+	Negotiator.prototype.preferredCharsets = Negotiator.prototype.charsets;
+	Negotiator.prototype.preferredEncoding = Negotiator.prototype.encoding;
+	Negotiator.prototype.preferredEncodings = Negotiator.prototype.encodings;
+	Negotiator.prototype.preferredLanguage = Negotiator.prototype.language;
+	Negotiator.prototype.preferredLanguages = Negotiator.prototype.languages;
+	Negotiator.prototype.preferredMediaType = Negotiator.prototype.mediaType;
+	Negotiator.prototype.preferredMediaTypes = Negotiator.prototype.mediaTypes;
+	return negotiator.exports;
+}
+
+export { requireNegotiator as __require };

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

@@ -0,0 +1,179 @@
+import { __module as charset } from '../../../../../_virtual/charset2.js';
+
+/**
+ * negotiator
+ * Copyright(c) 2012 Isaac Z. Schlueter
+ * Copyright(c) 2014 Federico Romero
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredCharset;
+
+function requireCharset () {
+	if (hasRequiredCharset) return charset.exports;
+	hasRequiredCharset = 1;
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	charset.exports = preferredCharsets;
+	charset.exports.preferredCharsets = preferredCharsets;
+
+	/**
+	 * Module variables.
+	 * @private
+	 */
+
+	var simpleCharsetRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
+
+	/**
+	 * Parse the Accept-Charset header.
+	 * @private
+	 */
+
+	function parseAcceptCharset(accept) {
+	  var accepts = accept.split(',');
+
+	  for (var i = 0, j = 0; i < accepts.length; i++) {
+	    var charset = parseCharset(accepts[i].trim(), i);
+
+	    if (charset) {
+	      accepts[j++] = charset;
+	    }
+	  }
+
+	  // trim accepts
+	  accepts.length = j;
+
+	  return accepts;
+	}
+
+	/**
+	 * Parse a charset from the Accept-Charset header.
+	 * @private
+	 */
+
+	function parseCharset(str, i) {
+	  var match = simpleCharsetRegExp.exec(str);
+	  if (!match) return null;
+
+	  var charset = match[1];
+	  var q = 1;
+	  if (match[2]) {
+	    var params = match[2].split(';');
+	    for (var j = 0; j < params.length; j++) {
+	      var p = params[j].trim().split('=');
+	      if (p[0] === 'q') {
+	        q = parseFloat(p[1]);
+	        break;
+	      }
+	    }
+	  }
+
+	  return {
+	    charset: charset,
+	    q: q,
+	    i: i
+	  };
+	}
+
+	/**
+	 * Get the priority of a charset.
+	 * @private
+	 */
+
+	function getCharsetPriority(charset, accepted, index) {
+	  var priority = {o: -1, q: 0, s: 0};
+
+	  for (var i = 0; i < accepted.length; i++) {
+	    var spec = specify(charset, 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 charset.
+	 * @private
+	 */
+
+	function specify(charset, spec, index) {
+	  var s = 0;
+	  if(spec.charset.toLowerCase() === charset.toLowerCase()){
+	    s |= 1;
+	  } else if (spec.charset !== '*' ) {
+	    return null
+	  }
+
+	  return {
+	    i: index,
+	    o: spec.i,
+	    q: spec.q,
+	    s: s
+	  }
+	}
+
+	/**
+	 * Get the preferred charsets from an Accept-Charset header.
+	 * @public
+	 */
+
+	function preferredCharsets(accept, provided) {
+	  // RFC 2616 sec 14.2: no header = *
+	  var accepts = parseAcceptCharset(accept === undefined ? '*' : accept || '');
+
+	  if (!provided) {
+	    // sorted list of all charsets
+	    return accepts
+	      .filter(isQuality)
+	      .sort(compareSpecs)
+	      .map(getFullCharset);
+	  }
+
+	  var priorities = provided.map(function getPriority(type, index) {
+	    return getCharsetPriority(type, accepts, index);
+	  });
+
+	  // sorted list of accepted charsets
+	  return priorities.filter(isQuality).sort(compareSpecs).map(function getCharset(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 charset string.
+	 * @private
+	 */
+
+	function getFullCharset(spec) {
+	  return spec.charset;
+	}
+
+	/**
+	 * Check if a spec has any quality.
+	 * @private
+	 */
+
+	function isQuality(spec) {
+	  return spec.q > 0;
+	}
+	return charset.exports;
+}
+
+export { requireCharset as __require };

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

@@ -0,0 +1,193 @@
+import { __module as encoding } from '../../../../../_virtual/encoding2.js';
+
+/**
+ * negotiator
+ * Copyright(c) 2012 Isaac Z. Schlueter
+ * Copyright(c) 2014 Federico Romero
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredEncoding;
+
+function requireEncoding () {
+	if (hasRequiredEncoding) return encoding.exports;
+	hasRequiredEncoding = 1;
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	encoding.exports = preferredEncodings;
+	encoding.exports.preferredEncodings = preferredEncodings;
+
+	/**
+	 * Module variables.
+	 * @private
+	 */
+
+	var simpleEncodingRegExp = /^\s*([^\s;]+)\s*(?:;(.*))?$/;
+
+	/**
+	 * Parse the Accept-Encoding header.
+	 * @private
+	 */
+
+	function parseAcceptEncoding(accept) {
+	  var accepts = accept.split(',');
+	  var hasIdentity = false;
+	  var minQuality = 1;
+
+	  for (var i = 0, j = 0; i < accepts.length; i++) {
+	    var encoding = parseEncoding(accepts[i].trim(), i);
+
+	    if (encoding) {
+	      accepts[j++] = encoding;
+	      hasIdentity = hasIdentity || specify('identity', encoding);
+	      minQuality = Math.min(minQuality, encoding.q || 1);
+	    }
+	  }
+
+	  if (!hasIdentity) {
+	    /*
+	     * If identity doesn't explicitly appear in the accept-encoding header,
+	     * it's added to the list of acceptable encoding with the lowest q
+	     */
+	    accepts[j++] = {
+	      encoding: 'identity',
+	      q: minQuality,
+	      i: i
+	    };
+	  }
+
+	  // trim accepts
+	  accepts.length = j;
+
+	  return accepts;
+	}
+
+	/**
+	 * Parse an encoding from the Accept-Encoding header.
+	 * @private
+	 */
+
+	function parseEncoding(str, i) {
+	  var match = simpleEncodingRegExp.exec(str);
+	  if (!match) return null;
+
+	  var encoding = match[1];
+	  var q = 1;
+	  if (match[2]) {
+	    var params = match[2].split(';');
+	    for (var j = 0; j < params.length; j++) {
+	      var p = params[j].trim().split('=');
+	      if (p[0] === 'q') {
+	        q = parseFloat(p[1]);
+	        break;
+	      }
+	    }
+	  }
+
+	  return {
+	    encoding: encoding,
+	    q: q,
+	    i: i
+	  };
+	}
+
+	/**
+	 * Get the priority of an encoding.
+	 * @private
+	 */
+
+	function getEncodingPriority(encoding, accepted, index) {
+	  var priority = {o: -1, q: 0, s: 0};
+
+	  for (var i = 0; i < accepted.length; i++) {
+	    var spec = specify(encoding, 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 encoding.
+	 * @private
+	 */
+
+	function specify(encoding, spec, index) {
+	  var s = 0;
+	  if(spec.encoding.toLowerCase() === encoding.toLowerCase()){
+	    s |= 1;
+	  } else if (spec.encoding !== '*' ) {
+	    return null
+	  }
+
+	  return {
+	    i: index,
+	    o: spec.i,
+	    q: spec.q,
+	    s: s
+	  }
+	}
+	/**
+	 * Get the preferred encodings from an Accept-Encoding header.
+	 * @public
+	 */
+
+	function preferredEncodings(accept, provided) {
+	  var accepts = parseAcceptEncoding(accept || '');
+
+	  if (!provided) {
+	    // sorted list of all encodings
+	    return accepts
+	      .filter(isQuality)
+	      .sort(compareSpecs)
+	      .map(getFullEncoding);
+	  }
+
+	  var priorities = provided.map(function getPriority(type, index) {
+	    return getEncodingPriority(type, accepts, index);
+	  });
+
+	  // sorted list of accepted encodings
+	  return priorities.filter(isQuality).sort(compareSpecs).map(function getEncoding(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 encoding string.
+	 * @private
+	 */
+
+	function getFullEncoding(spec) {
+	  return spec.encoding;
+	}
+
+	/**
+	 * Check if a spec has any quality.
+	 * @private
+	 */
+
+	function isQuality(spec) {
+	  return spec.q > 0;
+	}
+	return encoding.exports;
+}
+
+export { requireEncoding as __require };