@wabot-dev/framework 0.0.13 → 0.0.14

package/dist/src/node_modules/statuses/index.js

@@ -0,0 +1,157 @@
+import require$$0 from './codes.json.js';
+
+/*!
+ * statuses
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var statuses;
+var hasRequiredStatuses;
+
+function requireStatuses () {
+	if (hasRequiredStatuses) return statuses;
+	hasRequiredStatuses = 1;
+
+	/**
+	 * Module dependencies.
+	 * @private
+	 */
+
+	var codes = require$$0;
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	statuses = status;
+
+	// status code to message map
+	status.message = codes;
+
+	// status message (lower-case) to code map
+	status.code = createMessageToStatusCodeMap(codes);
+
+	// array of status codes
+	status.codes = createStatusCodeList(codes);
+
+	// status codes for redirects
+	status.redirect = {
+	  300: true,
+	  301: true,
+	  302: true,
+	  303: true,
+	  305: true,
+	  307: true,
+	  308: true
+	};
+
+	// status codes for empty bodies
+	status.empty = {
+	  204: true,
+	  205: true,
+	  304: true
+	};
+
+	// status codes for when you should retry the request
+	status.retry = {
+	  502: true,
+	  503: true,
+	  504: true
+	};
+
+	/**
+	 * Create a map of message to status code.
+	 * @private
+	 */
+
+	function createMessageToStatusCodeMap (codes) {
+	  var map = {};
+
+	  Object.keys(codes).forEach(function forEachCode (code) {
+	    var message = codes[code];
+	    var status = Number(code);
+
+	    // populate map
+	    map[message.toLowerCase()] = status;
+	  });
+
+	  return map
+	}
+
+	/**
+	 * Create a list of all status codes.
+	 * @private
+	 */
+
+	function createStatusCodeList (codes) {
+	  return Object.keys(codes).map(function mapCode (code) {
+	    return Number(code)
+	  })
+	}
+
+	/**
+	 * Get the status code for given message.
+	 * @private
+	 */
+
+	function getStatusCode (message) {
+	  var msg = message.toLowerCase();
+
+	  if (!Object.prototype.hasOwnProperty.call(status.code, msg)) {
+	    throw new Error('invalid status message: "' + message + '"')
+	  }
+
+	  return status.code[msg]
+	}
+
+	/**
+	 * Get the status message for given code.
+	 * @private
+	 */
+
+	function getStatusMessage (code) {
+	  if (!Object.prototype.hasOwnProperty.call(status.message, code)) {
+	    throw new Error('invalid status code: ' + code)
+	  }
+
+	  return status.message[code]
+	}
+
+	/**
+	 * Get the status code.
+	 *
+	 * Given a number, this will throw if it is not a known status
+	 * code, otherwise the code will be returned. Given a string,
+	 * the string will be parsed for a number and return the code
+	 * if valid, otherwise will lookup the code assuming this is
+	 * the status message.
+	 *
+	 * @param {string|number} code
+	 * @returns {number}
+	 * @public
+	 */
+
+	function status (code) {
+	  if (typeof code === 'number') {
+	    return getStatusMessage(code)
+	  }
+
+	  if (typeof code !== 'string') {
+	    throw new TypeError('code must be a number or string')
+	  }
+
+	  // '403'
+	  var n = parseInt(code, 10);
+	  if (!isNaN(n)) {
+	    return getStatusMessage(n)
+	  }
+
+	  return getStatusCode(code)
+	}
+	return statuses;
+}
+
+export { requireStatuses as __require };

package/dist/src/node_modules/toidentifier/index.js

@@ -0,0 +1,41 @@
+/*!
+ * toidentifier
+ * Copyright(c) 2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var toidentifier;
+var hasRequiredToidentifier;
+
+function requireToidentifier () {
+	if (hasRequiredToidentifier) return toidentifier;
+	hasRequiredToidentifier = 1;
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	toidentifier = toIdentifier;
+
+	/**
+	 * Trasform the given string into a JavaScript identifier
+	 *
+	 * @param {string} str
+	 * @returns {string}
+	 * @public
+	 */
+
+	function toIdentifier (str) {
+	  return str
+	    .split(' ')
+	    .map(function (token) {
+	      return token.slice(0, 1).toUpperCase() + token.slice(1)
+	    })
+	    .join('')
+	    .replace(/[^ _0-9a-z]/gi, '')
+	}
+	return toidentifier;
+}
+
+export { requireToidentifier as __require };

package/dist/src/node_modules/type-is/index.js

@@ -0,0 +1,263 @@
+import { __module as typeIs } from '../../_virtual/index11.js';
+import { __require as requireContentType } from '../content-type/index.js';
+import { __require as requireMimeTypes } from '../mime-types/index.js';
+import { __require as requireMediaTyper } from '../media-typer/index.js';
+
+/*!
+ * type-is
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2014-2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredTypeIs;
+
+function requireTypeIs () {
+	if (hasRequiredTypeIs) return typeIs.exports;
+	hasRequiredTypeIs = 1;
+
+	/**
+	 * Module dependencies.
+	 * @private
+	 */
+
+	var contentType = requireContentType();
+	var mime = requireMimeTypes();
+	var typer = requireMediaTyper();
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	typeIs.exports = typeofrequest;
+	typeIs.exports.is = typeis;
+	typeIs.exports.hasBody = hasbody;
+	typeIs.exports.normalize = normalize;
+	typeIs.exports.match = mimeMatch;
+
+	/**
+	 * Compare a `value` content-type with `types`.
+	 * Each `type` can be an extension like `html`,
+	 * a special shortcut like `multipart` or `urlencoded`,
+	 * or a mime type.
+	 *
+	 * If no types match, `false` is returned.
+	 * Otherwise, the first `type` that matches is returned.
+	 *
+	 * @param {String} value
+	 * @param {Array} types
+	 * @public
+	 */
+
+	function typeis (value, types_) {
+	  var i;
+	  var types = types_;
+
+	  // remove parameters and normalize
+	  var val = tryNormalizeType(value);
+
+	  // no type or invalid
+	  if (!val) {
+	    return false
+	  }
+
+	  // support flattened arguments
+	  if (types && !Array.isArray(types)) {
+	    types = new Array(arguments.length - 1);
+	    for (i = 0; i < types.length; i++) {
+	      types[i] = arguments[i + 1];
+	    }
+	  }
+
+	  // no types, return the content type
+	  if (!types || !types.length) {
+	    return val
+	  }
+
+	  var type;
+	  for (i = 0; i < types.length; i++) {
+	    if (mimeMatch(normalize(type = types[i]), val)) {
+	      return type[0] === '+' || type.indexOf('*') !== -1
+	        ? val
+	        : type
+	    }
+	  }
+
+	  // no matches
+	  return false
+	}
+
+	/**
+	 * Check if a request has a request body.
+	 * A request with a body __must__ either have `transfer-encoding`
+	 * or `content-length` headers set.
+	 * http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.3
+	 *
+	 * @param {Object} request
+	 * @return {Boolean}
+	 * @public
+	 */
+
+	function hasbody (req) {
+	  return req.headers['transfer-encoding'] !== undefined ||
+	    !isNaN(req.headers['content-length'])
+	}
+
+	/**
+	 * Check if the incoming request contains the "Content-Type"
+	 * header field, and it contains any of the give mime `type`s.
+	 * If there is no request body, `null` is returned.
+	 * If there is no content type, `false` is returned.
+	 * Otherwise, it returns the first `type` that matches.
+	 *
+	 * Examples:
+	 *
+	 *     // With Content-Type: text/html; charset=utf-8
+	 *     this.is('html'); // => 'html'
+	 *     this.is('text/html'); // => 'text/html'
+	 *     this.is('text/*', 'application/json'); // => 'text/html'
+	 *
+	 *     // When Content-Type is application/json
+	 *     this.is('json', 'urlencoded'); // => 'json'
+	 *     this.is('application/json'); // => 'application/json'
+	 *     this.is('html', 'application/*'); // => 'application/json'
+	 *
+	 *     this.is('html'); // => false
+	 *
+	 * @param {Object} req
+	 * @param {(String|Array)} types...
+	 * @return {(String|false|null)}
+	 * @public
+	 */
+
+	function typeofrequest (req, types_) {
+	  // no body
+	  if (!hasbody(req)) return null
+	  // support flattened arguments
+	  var types = arguments.length > 2
+	    ? Array.prototype.slice.call(arguments, 1)
+	    : types_;
+	  // request content type
+	  var value = req.headers['content-type'];
+
+	  return typeis(value, types)
+	}
+
+	/**
+	 * Normalize a mime type.
+	 * If it's a shorthand, expand it to a valid mime type.
+	 *
+	 * In general, you probably want:
+	 *
+	 *   var type = is(req, ['urlencoded', 'json', 'multipart']);
+	 *
+	 * Then use the appropriate body parsers.
+	 * These three are the most common request body types
+	 * and are thus ensured to work.
+	 *
+	 * @param {String} type
+	 * @return {String|false|null}
+	 * @public
+	 */
+
+	function normalize (type) {
+	  if (typeof type !== 'string') {
+	    // invalid type
+	    return false
+	  }
+
+	  switch (type) {
+	    case 'urlencoded':
+	      return 'application/x-www-form-urlencoded'
+	    case 'multipart':
+	      return 'multipart/*'
+	  }
+
+	  if (type[0] === '+') {
+	    // "+json" -> "*/*+json" expando
+	    return '*/*' + type
+	  }
+
+	  return type.indexOf('/') === -1
+	    ? mime.lookup(type)
+	    : type
+	}
+
+	/**
+	 * Check if `expected` mime type
+	 * matches `actual` mime type with
+	 * wildcard and +suffix support.
+	 *
+	 * @param {String} expected
+	 * @param {String} actual
+	 * @return {Boolean}
+	 * @public
+	 */
+
+	function mimeMatch (expected, actual) {
+	  // invalid type
+	  if (expected === false) {
+	    return false
+	  }
+
+	  // split types
+	  var actualParts = actual.split('/');
+	  var expectedParts = expected.split('/');
+
+	  // invalid format
+	  if (actualParts.length !== 2 || expectedParts.length !== 2) {
+	    return false
+	  }
+
+	  // validate type
+	  if (expectedParts[0] !== '*' && expectedParts[0] !== actualParts[0]) {
+	    return false
+	  }
+
+	  // validate suffix wildcard
+	  if (expectedParts[1].slice(0, 2) === '*+') {
+	    return expectedParts[1].length <= actualParts[1].length + 1 &&
+	      expectedParts[1].slice(1) === actualParts[1].slice(1 - expectedParts[1].length)
+	  }
+
+	  // validate subtype
+	  if (expectedParts[1] !== '*' && expectedParts[1] !== actualParts[1]) {
+	    return false
+	  }
+
+	  return true
+	}
+
+	/**
+	 * Normalize a type and remove parameters.
+	 *
+	 * @param {string} value
+	 * @return {(string|null)}
+	 * @private
+	 */
+	function normalizeType (value) {
+	  // Parse the type
+	  var type = contentType.parse(value).type;
+
+	  return typer.test(type) ? type : null
+	}
+
+	/**
+	 * Try to normalize a type and remove parameters.
+	 *
+	 * @param {string} value
+	 * @return {(string|null)}
+	 * @private
+	 */
+	function tryNormalizeType (value) {
+	  try {
+	    return value ? normalizeType(value) : null
+	  } catch (err) {
+	    return null
+	  }
+	}
+	return typeIs.exports;
+}
+
+export { requireTypeIs as __require };

package/dist/src/node_modules/unpipe/index.js

@@ -0,0 +1,78 @@
+/*!
+ * unpipe
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var unpipe_1;
+var hasRequiredUnpipe;
+
+function requireUnpipe () {
+	if (hasRequiredUnpipe) return unpipe_1;
+	hasRequiredUnpipe = 1;
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	unpipe_1 = unpipe;
+
+	/**
+	 * Determine if there are Node.js pipe-like data listeners.
+	 * @private
+	 */
+
+	function hasPipeDataListeners(stream) {
+	  var listeners = stream.listeners('data');
+
+	  for (var i = 0; i < listeners.length; i++) {
+	    if (listeners[i].name === 'ondata') {
+	      return true
+	    }
+	  }
+
+	  return false
+	}
+
+	/**
+	 * Unpipe a stream from all destinations.
+	 *
+	 * @param {object} stream
+	 * @public
+	 */
+
+	function unpipe(stream) {
+	  if (!stream) {
+	    throw new TypeError('argument stream is required')
+	  }
+
+	  if (typeof stream.unpipe === 'function') {
+	    // new-style
+	    stream.unpipe();
+	    return
+	  }
+
+	  // Node.js 0.8 hack
+	  if (!hasPipeDataListeners(stream)) {
+	    return
+	  }
+
+	  var listener;
+	  var listeners = stream.listeners('close');
+
+	  for (var i = 0; i < listeners.length; i++) {
+	    listener = listeners[i];
+
+	    if (listener.name !== 'cleanup' && listener.name !== 'onclose') {
+	      continue
+	    }
+
+	    // invoke the listener
+	    listener.call(stream);
+	  }
+	}
+	return unpipe_1;
+}
+
+export { requireUnpipe as __require };

package/dist/src/node_modules/vary/index.js

@@ -0,0 +1,159 @@
+import { __module as vary } from '../../_virtual/index27.js';
+
+/*!
+ * vary
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredVary;
+
+function requireVary () {
+	if (hasRequiredVary) return vary.exports;
+	hasRequiredVary = 1;
+
+	/**
+	 * Module exports.
+	 */
+
+	vary.exports = vary$1;
+	vary.exports.append = append;
+
+	/**
+	 * RegExp to match field-name in RFC 7230 sec 3.2
+	 *
+	 * field-name    = token
+	 * token         = 1*tchar
+	 * tchar         = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+	 *               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+	 *               / DIGIT / ALPHA
+	 *               ; any VCHAR, except delimiters
+	 */
+
+	var FIELD_NAME_REGEXP = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+
+	/**
+	 * Append a field to a vary header.
+	 *
+	 * @param {String} header
+	 * @param {String|Array} field
+	 * @return {String}
+	 * @public
+	 */
+
+	function append (header, field) {
+	  if (typeof header !== 'string') {
+	    throw new TypeError('header argument is required')
+	  }
+
+	  if (!field) {
+	    throw new TypeError('field argument is required')
+	  }
+
+	  // get fields array
+	  var fields = !Array.isArray(field)
+	    ? parse(String(field))
+	    : field;
+
+	  // assert on invalid field names
+	  for (var j = 0; j < fields.length; j++) {
+	    if (!FIELD_NAME_REGEXP.test(fields[j])) {
+	      throw new TypeError('field argument contains an invalid header name')
+	    }
+	  }
+
+	  // existing, unspecified vary
+	  if (header === '*') {
+	    return header
+	  }
+
+	  // enumerate current values
+	  var val = header;
+	  var vals = parse(header.toLowerCase());
+
+	  // unspecified vary
+	  if (fields.indexOf('*') !== -1 || vals.indexOf('*') !== -1) {
+	    return '*'
+	  }
+
+	  for (var i = 0; i < fields.length; i++) {
+	    var fld = fields[i].toLowerCase();
+
+	    // append value (case-preserving)
+	    if (vals.indexOf(fld) === -1) {
+	      vals.push(fld);
+	      val = val
+	        ? val + ', ' + fields[i]
+	        : fields[i];
+	    }
+	  }
+
+	  return val
+	}
+
+	/**
+	 * Parse a vary header into an array.
+	 *
+	 * @param {String} header
+	 * @return {Array}
+	 * @private
+	 */
+
+	function parse (header) {
+	  var end = 0;
+	  var list = [];
+	  var start = 0;
+
+	  // gather tokens
+	  for (var i = 0, len = header.length; i < len; i++) {
+	    switch (header.charCodeAt(i)) {
+	      case 0x20: /*   */
+	        if (start === end) {
+	          start = end = i + 1;
+	        }
+	        break
+	      case 0x2c: /* , */
+	        list.push(header.substring(start, end));
+	        start = end = i + 1;
+	        break
+	      default:
+	        end = i + 1;
+	        break
+	    }
+	  }
+
+	  // final token
+	  list.push(header.substring(start, end));
+
+	  return list
+	}
+
+	/**
+	 * Mark that a request is varied on a header field.
+	 *
+	 * @param {Object} res
+	 * @param {String|Array} field
+	 * @public
+	 */
+
+	function vary$1 (res, field) {
+	  if (!res || !res.getHeader || !res.setHeader) {
+	    // quack quack
+	    throw new TypeError('res argument is required')
+	  }
+
+	  // get existing header
+	  var val = res.getHeader('Vary') || '';
+	  var header = Array.isArray(val)
+	    ? val.join(', ')
+	    : String(val);
+
+	  // set new header
+	  if ((val = append(header, field))) {
+	    res.setHeader('Vary', val);
+	  }
+	}
+	return vary.exports;
+}
+
+export { requireVary as __require };