@wabot-dev/framework 0.0.12 → 0.0.14

package/dist/src/node_modules/inherits/inherits_browser.js

@@ -0,0 +1,38 @@
+import { __module as inherits_browser } from '../../_virtual/inherits_browser.js';
+
+var hasRequiredInherits_browser;
+
+function requireInherits_browser () {
+	if (hasRequiredInherits_browser) return inherits_browser.exports;
+	hasRequiredInherits_browser = 1;
+	if (typeof Object.create === 'function') {
+	  // implementation from standard node.js 'util' module
+	  inherits_browser.exports = function inherits(ctor, superCtor) {
+	    if (superCtor) {
+	      ctor.super_ = superCtor;
+	      ctor.prototype = Object.create(superCtor.prototype, {
+	        constructor: {
+	          value: ctor,
+	          enumerable: false,
+	          writable: true,
+	          configurable: true
+	        }
+	      });
+	    }
+	  };
+	} else {
+	  // old school shim for old browsers
+	  inherits_browser.exports = function inherits(ctor, superCtor) {
+	    if (superCtor) {
+	      ctor.super_ = superCtor;
+	      var TempCtor = function () {};
+	      TempCtor.prototype = superCtor.prototype;
+	      ctor.prototype = new TempCtor();
+	      ctor.prototype.constructor = ctor;
+	    }
+	  };
+	}
+	return inherits_browser.exports;
+}
+
+export { requireInherits_browser as __require };

package/dist/src/node_modules/math-intrinsics/abs.js

@@ -0,0 +1,13 @@
+var abs;
+var hasRequiredAbs;
+
+function requireAbs () {
+	if (hasRequiredAbs) return abs;
+	hasRequiredAbs = 1;
+
+	/** @type {import('./abs')} */
+	abs = Math.abs;
+	return abs;
+}
+
+export { requireAbs as __require };

package/dist/src/node_modules/math-intrinsics/floor.js

@@ -0,0 +1,13 @@
+var floor;
+var hasRequiredFloor;
+
+function requireFloor () {
+	if (hasRequiredFloor) return floor;
+	hasRequiredFloor = 1;
+
+	/** @type {import('./floor')} */
+	floor = Math.floor;
+	return floor;
+}
+
+export { requireFloor as __require };

package/dist/src/node_modules/math-intrinsics/isNaN.js

@@ -0,0 +1,15 @@
+var _isNaN;
+var hasRequired_isNaN;
+
+function require_isNaN () {
+	if (hasRequired_isNaN) return _isNaN;
+	hasRequired_isNaN = 1;
+
+	/** @type {import('./isNaN')} */
+	_isNaN = Number.isNaN || function isNaN(a) {
+		return a !== a;
+	};
+	return _isNaN;
+}
+
+export { require_isNaN as __require };

package/dist/src/node_modules/math-intrinsics/max.js

@@ -0,0 +1,13 @@
+var max;
+var hasRequiredMax;
+
+function requireMax () {
+	if (hasRequiredMax) return max;
+	hasRequiredMax = 1;
+
+	/** @type {import('./max')} */
+	max = Math.max;
+	return max;
+}
+
+export { requireMax as __require };

package/dist/src/node_modules/math-intrinsics/min.js

@@ -0,0 +1,13 @@
+var min;
+var hasRequiredMin;
+
+function requireMin () {
+	if (hasRequiredMin) return min;
+	hasRequiredMin = 1;
+
+	/** @type {import('./min')} */
+	min = Math.min;
+	return min;
+}
+
+export { requireMin as __require };

package/dist/src/node_modules/math-intrinsics/pow.js

@@ -0,0 +1,13 @@
+var pow;
+var hasRequiredPow;
+
+function requirePow () {
+	if (hasRequiredPow) return pow;
+	hasRequiredPow = 1;
+
+	/** @type {import('./pow')} */
+	pow = Math.pow;
+	return pow;
+}
+
+export { requirePow as __require };

package/dist/src/node_modules/math-intrinsics/round.js

@@ -0,0 +1,13 @@
+var round;
+var hasRequiredRound;
+
+function requireRound () {
+	if (hasRequiredRound) return round;
+	hasRequiredRound = 1;
+
+	/** @type {import('./round')} */
+	round = Math.round;
+	return round;
+}
+
+export { requireRound as __require };

package/dist/src/node_modules/math-intrinsics/sign.js

@@ -0,0 +1,22 @@
+import { __require as require_isNaN } from './isNaN.js';
+
+var sign;
+var hasRequiredSign;
+
+function requireSign () {
+	if (hasRequiredSign) return sign;
+	hasRequiredSign = 1;
+
+	var $isNaN = /*@__PURE__*/ require_isNaN();
+
+	/** @type {import('./sign')} */
+	sign = function sign(number) {
+		if ($isNaN(number) || number === 0) {
+			return number;
+		}
+		return number < 0 ? -1 : 1;
+	};
+	return sign;
+}
+
+export { requireSign as __require };

package/dist/src/node_modules/media-typer/index.js

@@ -0,0 +1,153 @@
+import { __exports as mediaTyper } from '../../_virtual/index25.js';
+
+/*!
+ * media-typer
+ * Copyright(c) 2014-2017 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredMediaTyper;
+
+function requireMediaTyper () {
+	if (hasRequiredMediaTyper) return mediaTyper;
+	hasRequiredMediaTyper = 1;
+
+	/**
+	 * RegExp to match type in RFC 6838
+	 *
+	 * type-name = restricted-name
+	 * subtype-name = restricted-name
+	 * restricted-name = restricted-name-first *126restricted-name-chars
+	 * restricted-name-first  = ALPHA / DIGIT
+	 * restricted-name-chars  = ALPHA / DIGIT / "!" / "#" /
+	 *                          "$" / "&" / "-" / "^" / "_"
+	 * restricted-name-chars =/ "." ; Characters before first dot always
+	 *                              ; specify a facet name
+	 * restricted-name-chars =/ "+" ; Characters after last plus always
+	 *                              ; specify a structured syntax suffix
+	 * ALPHA =  %x41-5A / %x61-7A   ; A-Z / a-z
+	 * DIGIT =  %x30-39             ; 0-9
+	 */
+	var SUBTYPE_NAME_REGEXP = /^[A-Za-z0-9][A-Za-z0-9!#$&^_.-]{0,126}$/;
+	var TYPE_NAME_REGEXP = /^[A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126}$/;
+	var TYPE_REGEXP = /^ *([A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126})\/([A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126}) *$/;
+
+	/**
+	 * Module exports.
+	 */
+
+	mediaTyper.format = format;
+	mediaTyper.parse = parse;
+	mediaTyper.test = test;
+
+	/**
+	 * 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 subtype = obj.subtype;
+	  var suffix = obj.suffix;
+	  var type = obj.type;
+
+	  if (!type || !TYPE_NAME_REGEXP.test(type)) {
+	    throw new TypeError('invalid type')
+	  }
+
+	  if (!subtype || !SUBTYPE_NAME_REGEXP.test(subtype)) {
+	    throw new TypeError('invalid subtype')
+	  }
+
+	  // format as type/subtype
+	  var string = type + '/' + subtype;
+
+	  // append +suffix
+	  if (suffix) {
+	    if (!TYPE_NAME_REGEXP.test(suffix)) {
+	      throw new TypeError('invalid suffix')
+	    }
+
+	    string += '+' + suffix;
+	  }
+
+	  return string
+	}
+
+	/**
+	 * Test media type.
+	 *
+	 * @param {string} string
+	 * @return {object}
+	 * @public
+	 */
+
+	function test (string) {
+	  if (!string) {
+	    throw new TypeError('argument string is required')
+	  }
+
+	  if (typeof string !== 'string') {
+	    throw new TypeError('argument string is required to be a string')
+	  }
+
+	  return TYPE_REGEXP.test(string.toLowerCase())
+	}
+
+	/**
+	 * Parse media type to object.
+	 *
+	 * @param {string} string
+	 * @return {object}
+	 * @public
+	 */
+
+	function parse (string) {
+	  if (!string) {
+	    throw new TypeError('argument string is required')
+	  }
+
+	  if (typeof string !== 'string') {
+	    throw new TypeError('argument string is required to be a string')
+	  }
+
+	  var match = TYPE_REGEXP.exec(string.toLowerCase());
+
+	  if (!match) {
+	    throw new TypeError('invalid media type')
+	  }
+
+	  var type = match[1];
+	  var subtype = match[2];
+	  var suffix;
+
+	  // suffix after last +
+	  var index = subtype.lastIndexOf('+');
+	  if (index !== -1) {
+	    suffix = subtype.substr(index + 1);
+	    subtype = subtype.substr(0, index);
+	  }
+
+	  return new MediaType(type, subtype, suffix)
+	}
+
+	/**
+	 * Class for MediaType object.
+	 * @public
+	 */
+
+	function MediaType (type, subtype, suffix) {
+	  this.type = type;
+	  this.subtype = subtype;
+	  this.suffix = suffix;
+	}
+	return mediaTyper;
+}
+
+export { requireMediaTyper as __require };