@wabot-dev/framework 0.0.13 → 0.0.14

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

@@ -0,0 +1,180 @@
+import { __module as bytes } from '../../_virtual/index18.js';
+
+/*!
+ * bytes
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015 Jed Watson
+ * MIT Licensed
+ */
+
+var hasRequiredBytes;
+
+function requireBytes () {
+	if (hasRequiredBytes) return bytes.exports;
+	hasRequiredBytes = 1;
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	bytes.exports = bytes$1;
+	bytes.exports.format = format;
+	bytes.exports.parse = parse;
+
+	/**
+	 * Module variables.
+	 * @private
+	 */
+
+	var formatThousandsRegExp = /\B(?=(\d{3})+(?!\d))/g;
+
+	var formatDecimalsRegExp = /(?:\.0*|(\.[^0]+)0+)$/;
+
+	var map = {
+	  b:  1,
+	  kb: 1 << 10,
+	  mb: 1 << 20,
+	  gb: 1 << 30,
+	  tb: Math.pow(1024, 4),
+	  pb: Math.pow(1024, 5),
+	};
+
+	var parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i;
+
+	/**
+	 * Convert the given value in bytes into a string or parse to string to an integer in bytes.
+	 *
+	 * @param {string|number} value
+	 * @param {{
+	 *  case: [string],
+	 *  decimalPlaces: [number]
+	 *  fixedDecimals: [boolean]
+	 *  thousandsSeparator: [string]
+	 *  unitSeparator: [string]
+	 *  }} [options] bytes options.
+	 *
+	 * @returns {string|number|null}
+	 */
+
+	function bytes$1(value, options) {
+	  if (typeof value === 'string') {
+	    return parse(value);
+	  }
+
+	  if (typeof value === 'number') {
+	    return format(value, options);
+	  }
+
+	  return null;
+	}
+
+	/**
+	 * Format the given value in bytes into a string.
+	 *
+	 * If the value is negative, it is kept as such. If it is a float,
+	 * it is rounded.
+	 *
+	 * @param {number} value
+	 * @param {object} [options]
+	 * @param {number} [options.decimalPlaces=2]
+	 * @param {number} [options.fixedDecimals=false]
+	 * @param {string} [options.thousandsSeparator=]
+	 * @param {string} [options.unit=]
+	 * @param {string} [options.unitSeparator=]
+	 *
+	 * @returns {string|null}
+	 * @public
+	 */
+
+	function format(value, options) {
+	  if (!Number.isFinite(value)) {
+	    return null;
+	  }
+
+	  var mag = Math.abs(value);
+	  var thousandsSeparator = (options && options.thousandsSeparator) || '';
+	  var unitSeparator = (options && options.unitSeparator) || '';
+	  var decimalPlaces = (options && options.decimalPlaces !== undefined) ? options.decimalPlaces : 2;
+	  var fixedDecimals = Boolean(options && options.fixedDecimals);
+	  var unit = (options && options.unit) || '';
+
+	  if (!unit || !map[unit.toLowerCase()]) {
+	    if (mag >= map.pb) {
+	      unit = 'PB';
+	    } else if (mag >= map.tb) {
+	      unit = 'TB';
+	    } else if (mag >= map.gb) {
+	      unit = 'GB';
+	    } else if (mag >= map.mb) {
+	      unit = 'MB';
+	    } else if (mag >= map.kb) {
+	      unit = 'KB';
+	    } else {
+	      unit = 'B';
+	    }
+	  }
+
+	  var val = value / map[unit.toLowerCase()];
+	  var str = val.toFixed(decimalPlaces);
+
+	  if (!fixedDecimals) {
+	    str = str.replace(formatDecimalsRegExp, '$1');
+	  }
+
+	  if (thousandsSeparator) {
+	    str = str.split('.').map(function (s, i) {
+	      return i === 0
+	        ? s.replace(formatThousandsRegExp, thousandsSeparator)
+	        : s
+	    }).join('.');
+	  }
+
+	  return str + unitSeparator + unit;
+	}
+
+	/**
+	 * Parse the string value into an integer in bytes.
+	 *
+	 * If no unit is given, it is assumed the value is in bytes.
+	 *
+	 * @param {number|string} val
+	 *
+	 * @returns {number|null}
+	 * @public
+	 */
+
+	function parse(val) {
+	  if (typeof val === 'number' && !isNaN(val)) {
+	    return val;
+	  }
+
+	  if (typeof val !== 'string') {
+	    return null;
+	  }
+
+	  // Test if the string passed is valid
+	  var results = parseRegExp.exec(val);
+	  var floatValue;
+	  var unit = 'b';
+
+	  if (!results) {
+	    // Nothing could be extracted from the given string
+	    floatValue = parseInt(val, 10);
+	    unit = 'b';
+	  } else {
+	    // Retrieve the value and the unit
+	    floatValue = parseFloat(results[1]);
+	    unit = results[4].toLowerCase();
+	  }
+
+	  if (isNaN(floatValue)) {
+	    return null;
+	  }
+
+	  return Math.floor(map[unit] * floatValue);
+	}
+	return bytes.exports;
+}
+
+export { requireBytes as __require };

package/dist/src/node_modules/call-bind-apply-helpers/actualApply.js

@@ -0,0 +1,24 @@
+import { __require as requireFunctionBind } from '../function-bind/index.js';
+import { __require as requireFunctionApply } from './functionApply.js';
+import { __require as requireFunctionCall } from './functionCall.js';
+import { __require as requireReflectApply } from './reflectApply.js';
+
+var actualApply;
+var hasRequiredActualApply;
+
+function requireActualApply () {
+	if (hasRequiredActualApply) return actualApply;
+	hasRequiredActualApply = 1;
+
+	var bind = requireFunctionBind();
+
+	var $apply = requireFunctionApply();
+	var $call = requireFunctionCall();
+	var $reflectApply = requireReflectApply();
+
+	/** @type {import('./actualApply')} */
+	actualApply = $reflectApply || bind.call($call, $apply);
+	return actualApply;
+}
+
+export { requireActualApply as __require };

package/dist/src/node_modules/call-bind-apply-helpers/functionApply.js

@@ -0,0 +1,13 @@
+var functionApply;
+var hasRequiredFunctionApply;
+
+function requireFunctionApply () {
+	if (hasRequiredFunctionApply) return functionApply;
+	hasRequiredFunctionApply = 1;
+
+	/** @type {import('./functionApply')} */
+	functionApply = Function.prototype.apply;
+	return functionApply;
+}
+
+export { requireFunctionApply as __require };

package/dist/src/node_modules/call-bind-apply-helpers/functionCall.js

@@ -0,0 +1,13 @@
+var functionCall;
+var hasRequiredFunctionCall;
+
+function requireFunctionCall () {
+	if (hasRequiredFunctionCall) return functionCall;
+	hasRequiredFunctionCall = 1;
+
+	/** @type {import('./functionCall')} */
+	functionCall = Function.prototype.call;
+	return functionCall;
+}
+
+export { requireFunctionCall as __require };

package/dist/src/node_modules/call-bind-apply-helpers/index.js

@@ -0,0 +1,29 @@
+import { __require as requireFunctionBind } from '../function-bind/index.js';
+import { __require as requireType } from '../es-errors/type.js';
+import { __require as requireFunctionCall } from './functionCall.js';
+import { __require as requireActualApply } from './actualApply.js';
+
+var callBindApplyHelpers;
+var hasRequiredCallBindApplyHelpers;
+
+function requireCallBindApplyHelpers () {
+	if (hasRequiredCallBindApplyHelpers) return callBindApplyHelpers;
+	hasRequiredCallBindApplyHelpers = 1;
+
+	var bind = requireFunctionBind();
+	var $TypeError = /*@__PURE__*/ requireType();
+
+	var $call = requireFunctionCall();
+	var $actualApply = requireActualApply();
+
+	/** @type {(args: [Function, thisArg?: unknown, ...args: unknown[]]) => Function} TODO FIXME, find a way to use import('.') */
+	callBindApplyHelpers = function callBindBasic(args) {
+		if (args.length < 1 || typeof args[0] !== 'function') {
+			throw new $TypeError('a function is required');
+		}
+		return $actualApply(bind, $call, args);
+	};
+	return callBindApplyHelpers;
+}
+
+export { requireCallBindApplyHelpers as __require };

package/dist/src/node_modules/call-bind-apply-helpers/reflectApply.js

@@ -0,0 +1,13 @@
+var reflectApply;
+var hasRequiredReflectApply;
+
+function requireReflectApply () {
+	if (hasRequiredReflectApply) return reflectApply;
+	hasRequiredReflectApply = 1;
+
+	/** @type {import('./reflectApply')} */
+	reflectApply = typeof Reflect !== 'undefined' && Reflect && Reflect.apply;
+	return reflectApply;
+}
+
+export { requireReflectApply as __require };

package/dist/src/node_modules/call-bound/index.js

@@ -0,0 +1,31 @@
+import { __require as requireGetIntrinsic } from '../get-intrinsic/index.js';
+import { __require as requireCallBindApplyHelpers } from '../call-bind-apply-helpers/index.js';
+
+var callBound;
+var hasRequiredCallBound;
+
+function requireCallBound () {
+	if (hasRequiredCallBound) return callBound;
+	hasRequiredCallBound = 1;
+
+	var GetIntrinsic = /*@__PURE__*/ requireGetIntrinsic();
+
+	var callBindBasic = requireCallBindApplyHelpers();
+
+	/** @type {(thisArg: string, searchString: string, position?: number) => number} */
+	var $indexOf = callBindBasic([GetIntrinsic('%String.prototype.indexOf%')]);
+
+	/** @type {import('.')} */
+	callBound = function callBoundIntrinsic(name, allowMissing) {
+		/* eslint no-extra-parens: 0 */
+
+		var intrinsic = /** @type {(this: unknown, ...args: unknown[]) => unknown} */ (GetIntrinsic(name, !!allowMissing));
+		if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
+			return callBindBasic(/** @type {const} */ ([intrinsic]));
+		}
+		return intrinsic;
+	};
+	return callBound;
+}
+
+export { requireCallBound as __require };

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

@@ -0,0 +1,235 @@
+import { __exports as contentType } from '../../_virtual/index17.js';
+
+/*!
+ * content-type
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredContentType;
+
+function requireContentType () {
+	if (hasRequiredContentType) return contentType;
+	hasRequiredContentType = 1;
+
+	/**
+	 * RegExp to match *( ";" parameter ) in RFC 7231 sec 3.1.1.1
+	 *
+	 * parameter     = token "=" ( token / quoted-string )
+	 * token         = 1*tchar
+	 * tchar         = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+	 *               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+	 *               / DIGIT / ALPHA
+	 *               ; any VCHAR, except delimiters
+	 * quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE
+	 * qdtext        = HTAB / SP / %x21 / %x23-5B / %x5D-7E / obs-text
+	 * obs-text      = %x80-FF
+	 * quoted-pair   = "\" ( HTAB / SP / VCHAR / obs-text )
+	 */
+	var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g; // eslint-disable-line no-control-regex
+	var TEXT_REGEXP = /^[\u000b\u0020-\u007e\u0080-\u00ff]+$/; // eslint-disable-line no-control-regex
+	var TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+
+	/**
+	 * RegExp to match quoted-pair in RFC 7230 sec 3.2.6
+	 *
+	 * quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text )
+	 * obs-text    = %x80-FF
+	 */
+	var QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g; // eslint-disable-line no-control-regex
+
+	/**
+	 * RegExp to match chars that must be quoted-pair in RFC 7230 sec 3.2.6
+	 */
+	var QUOTE_REGEXP = /([\\"])/g;
+
+	/**
+	 * RegExp to match type in RFC 7231 sec 3.1.1.1
+	 *
+	 * media-type = type "/" subtype
+	 * type       = token
+	 * subtype    = token
+	 */
+	var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	contentType.format = format;
+	contentType.parse = parse;
+
+	/**
+	 * Format object to media type.
+	 *
+	 * @param {object} obj
+	 * @return {string}
+	 * @public
+	 */
+
+	function format (obj) {
+	  if (!obj || typeof obj !== 'object') {
+	    throw new TypeError('argument obj is required')
+	  }
+
+	  var parameters = obj.parameters;
+	  var type = obj.type;
+
+	  if (!type || !TYPE_REGEXP.test(type)) {
+	    throw new TypeError('invalid type')
+	  }
+
+	  var string = type;
+
+	  // append parameters
+	  if (parameters && typeof parameters === 'object') {
+	    var param;
+	    var params = Object.keys(parameters).sort();
+
+	    for (var i = 0; i < params.length; i++) {
+	      param = params[i];
+
+	      if (!TOKEN_REGEXP.test(param)) {
+	        throw new TypeError('invalid parameter name')
+	      }
+
+	      string += '; ' + param + '=' + qstring(parameters[param]);
+	    }
+	  }
+
+	  return string
+	}
+
+	/**
+	 * Parse media type to object.
+	 *
+	 * @param {string|object} string
+	 * @return {Object}
+	 * @public
+	 */
+
+	function parse (string) {
+	  if (!string) {
+	    throw new TypeError('argument string is required')
+	  }
+
+	  // support req/res-like objects as argument
+	  var header = typeof string === 'object'
+	    ? getcontenttype(string)
+	    : string;
+
+	  if (typeof header !== 'string') {
+	    throw new TypeError('argument string is required to be a string')
+	  }
+
+	  var index = header.indexOf(';');
+	  var type = index !== -1
+	    ? header.slice(0, index).trim()
+	    : header.trim();
+
+	  if (!TYPE_REGEXP.test(type)) {
+	    throw new TypeError('invalid media type')
+	  }
+
+	  var obj = new ContentType(type.toLowerCase());
+
+	  // parse parameters
+	  if (index !== -1) {
+	    var key;
+	    var match;
+	    var value;
+
+	    PARAM_REGEXP.lastIndex = index;
+
+	    while ((match = PARAM_REGEXP.exec(header))) {
+	      if (match.index !== index) {
+	        throw new TypeError('invalid parameter format')
+	      }
+
+	      index += match[0].length;
+	      key = match[1].toLowerCase();
+	      value = match[2];
+
+	      if (value.charCodeAt(0) === 0x22 /* " */) {
+	        // remove quotes
+	        value = value.slice(1, -1);
+
+	        // remove escapes
+	        if (value.indexOf('\\') !== -1) {
+	          value = value.replace(QESC_REGEXP, '$1');
+	        }
+	      }
+
+	      obj.parameters[key] = value;
+	    }
+
+	    if (index !== header.length) {
+	      throw new TypeError('invalid parameter format')
+	    }
+	  }
+
+	  return obj
+	}
+
+	/**
+	 * Get content-type from req/res objects.
+	 *
+	 * @param {object}
+	 * @return {Object}
+	 * @private
+	 */
+
+	function getcontenttype (obj) {
+	  var header;
+
+	  if (typeof obj.getHeader === 'function') {
+	    // res-like
+	    header = obj.getHeader('content-type');
+	  } else if (typeof obj.headers === 'object') {
+	    // req-like
+	    header = obj.headers && obj.headers['content-type'];
+	  }
+
+	  if (typeof header !== 'string') {
+	    throw new TypeError('content-type header is missing from object')
+	  }
+
+	  return header
+	}
+
+	/**
+	 * Quote a string if necessary.
+	 *
+	 * @param {string} val
+	 * @return {string}
+	 * @private
+	 */
+
+	function qstring (val) {
+	  var str = String(val);
+
+	  // no need to quote tokens
+	  if (TOKEN_REGEXP.test(str)) {
+	    return str
+	  }
+
+	  if (str.length > 0 && !TEXT_REGEXP.test(str)) {
+	    throw new TypeError('invalid parameter value')
+	  }
+
+	  return '"' + str.replace(QUOTE_REGEXP, '\\$1') + '"'
+	}
+
+	/**
+	 * Class to represent a content type.
+	 * @private
+	 */
+	function ContentType (type) {
+	  this.parameters = Object.create(null);
+	  this.type = type;
+	}
+	return contentType;
+}
+
+export { requireContentType as __require };