@nebula.js/stardust 6.0.0-alpha.1 → 6.0.0-alpha.2

package/dist/stardust.dev.js

@@ -1,5 +1,5 @@
 /*
-* @nebula.js/stardust v6.0.0-alpha.1
+* @nebula.js/stardust v6.0.0-alpha.2
 * Copyright (c) 2025 QlikTech International AB
 * Released under the MIT license.
 */
@@ -7829,7 +7829,7 @@
 	  };
 	}
 
-	var identifierWithPointTracking = function identifierWithPointTracking(begin, points, index) {
+	var identifierWithPointTracking$1 = function identifierWithPointTracking(begin, points, index) {
 	  var previous = 0;
 	  var character = 0;
 
@@ -7851,7 +7851,7 @@
 	  return slice(begin, position);
 	};
 
-	var toRules = function toRules(parsed, points) {
+	var toRules$1 = function toRules(parsed, points) {
 	  // pretend we've started with a comma
 	  var index = -1;
 	  var character = 44;
@@ -7868,7 +7868,7 @@
 	          points[index] = 1;
 	        }
 
-	        parsed[index] += identifierWithPointTracking(position - 1, points, index);
+	        parsed[index] += identifierWithPointTracking$1(position - 1, points, index);
 	        break;
 
 	      case 2:
@@ -7894,13 +7894,13 @@
 	  return parsed;
 	};
 
-	var getRules = function getRules(value, points) {
-	  return dealloc(toRules(alloc(value), points));
+	var getRules$1 = function getRules(value, points) {
+	  return dealloc(toRules$1(alloc(value), points));
 	}; // WeakSet would be more appropriate, but only WeakMap is supported in IE11
 
 
-	var fixedElements = /* #__PURE__ */new WeakMap();
-	var compat = function compat(element) {
+	var fixedElements$1 = /* #__PURE__ */new WeakMap();
+	var compat$1 = function compat(element) {
 	  if (element.type !== 'rule' || !element.parent || // positive .length indicates that this rule contains pseudo
 	  // negative .length indicates that this rule has been already prefixed
 	  element.length < 1) {
@@ -7919,7 +7919,7 @@
 
 	  if (element.props.length === 1 && value.charCodeAt(0) !== 58
 	  /* colon */
-	  && !fixedElements.get(parent)) {
+	  && !fixedElements$1.get(parent)) {
 	    return;
 	  } // if this is an implicitly inserted rule (the one eagerly inserted at the each new nested level)
 	  // then the props has already been manipulated beforehand as they that array is shared between it and its "rule parent"
@@ -7929,9 +7929,9 @@
 	    return;
 	  }
 
-	  fixedElements.set(element, true);
+	  fixedElements$1.set(element, true);
 	  var points = [];
-	  var rules = getRules(value, points);
+	  var rules = getRules$1(value, points);
 	  var parentRules = parent.props;
 
 	  for (var i = 0, k = 0; i < rules.length; i++) {
@@ -7940,7 +7940,7 @@
 	    }
 	  }
 	};
-	var removeLabel = function removeLabel(element) {
+	var removeLabel$1 = function removeLabel(element) {
 	  if (element.type === 'decl') {
 	    var value = element.value;
 
@@ -7956,7 +7956,7 @@
 
 	/* eslint-disable no-fallthrough */
 
-	function prefix(value, length) {
+	function prefix$1(value, length) {
 	  switch (hash$2(value, length)) {
 	    // color-adjust
 	    case 5103:
@@ -8084,7 +8084,7 @@
 	        // (s)tretch
 
 	        case 115:
-	          return ~indexof(value, 'stretch') ? prefix(replace(value, 'stretch', 'fill-available'), length) + value : value;
+	          return ~indexof(value, 'stretch') ? prefix$1(replace(value, 'stretch', 'fill-available'), length) + value : value;
 	      }
 	      break;
 	    // position: sticky
@@ -8129,10 +8129,10 @@
 	  return value;
 	}
 
-	var prefixer = function prefixer(element, index, children, callback) {
+	var prefixer$1 = function prefixer(element, index, children, callback) {
 	  if (element.length > -1) if (!element["return"]) switch (element.type) {
 	    case DECLARATION:
-	      element["return"] = prefix(element.value, element.length);
+	      element["return"] = prefix$1(element.value, element.length);
 	      break;
 
 	    case KEYFRAMES:
@@ -8166,9 +8166,9 @@
 	  }
 	};
 
-	var defaultStylisPlugins = [prefixer];
+	var defaultStylisPlugins$1 = [prefixer$1];
 
-	var createCache = function createCache(options) {
+	var createCache$1 = function createCache(options) {
 	  var key = options.key;
 
 	  if (key === 'css') {
@@ -8195,7 +8195,7 @@
 	    });
 	  }
 
-	  var stylisPlugins = options.stylisPlugins || defaultStylisPlugins;
+	  var stylisPlugins = options.stylisPlugins || defaultStylisPlugins$1;
 
 	  var inserted = {};
 	  var container;
@@ -8218,7 +8218,7 @@
 
 	  var _insert;
 
-	  var omnipresentPlugins = [compat, removeLabel];
+	  var omnipresentPlugins = [compat$1, removeLabel$1];
 
 	  {
 	    var currentSheet;
@@ -8800,7 +8800,7 @@
 	// and we could have a special build just for that
 	// but this is much easier and the native packages
 	// might use a different theme context in the future anyway
-	typeof HTMLElement !== 'undefined' ? /* #__PURE__ */createCache({
+	typeof HTMLElement !== 'undefined' ? /* #__PURE__ */createCache$1({
 	  key: 'css'
 	}) : null);
 
@@ -9007,7 +9007,7 @@
 	}
 
 	// eslint-disable-next-line no-undef
-	var reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|disableRemotePlayback|download|draggable|encType|enterKeyHint|fetchpriority|fetchPriority|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23
+	var reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|disableRemotePlayback|download|draggable|encType|enterKeyHint|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23
 
 	var isPropValid = /* #__PURE__ */memoize$1(function (prop) {
 	  return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111
@@ -9185,6 +9185,467 @@
 	  styled$3[tagName] = styled$3(tagName);
 	});
 
+	var identifierWithPointTracking = function identifierWithPointTracking(begin, points, index) {
+	  var previous = 0;
+	  var character = 0;
+
+	  while (true) {
+	    previous = character;
+	    character = peek(); // &\f
+
+	    if (previous === 38 && character === 12) {
+	      points[index] = 1;
+	    }
+
+	    if (token(character)) {
+	      break;
+	    }
+
+	    next();
+	  }
+
+	  return slice(begin, position);
+	};
+
+	var toRules = function toRules(parsed, points) {
+	  // pretend we've started with a comma
+	  var index = -1;
+	  var character = 44;
+
+	  do {
+	    switch (token(character)) {
+	      case 0:
+	        // &\f
+	        if (character === 38 && peek() === 12) {
+	          // this is not 100% correct, we don't account for literal sequences here - like for example quoted strings
+	          // stylis inserts \f after & to know when & where it should replace this sequence with the context selector
+	          // and when it should just concatenate the outer and inner selectors
+	          // it's very unlikely for this sequence to actually appear in a different context, so we just leverage this fact here
+	          points[index] = 1;
+	        }
+
+	        parsed[index] += identifierWithPointTracking(position - 1, points, index);
+	        break;
+
+	      case 2:
+	        parsed[index] += delimit(character);
+	        break;
+
+	      case 4:
+	        // comma
+	        if (character === 44) {
+	          // colon
+	          parsed[++index] = peek() === 58 ? '&\f' : '';
+	          points[index] = parsed[index].length;
+	          break;
+	        }
+
+	      // fallthrough
+
+	      default:
+	        parsed[index] += from(character);
+	    }
+	  } while (character = next());
+
+	  return parsed;
+	};
+
+	var getRules = function getRules(value, points) {
+	  return dealloc(toRules(alloc(value), points));
+	}; // WeakSet would be more appropriate, but only WeakMap is supported in IE11
+
+
+	var fixedElements = /* #__PURE__ */new WeakMap();
+	var compat = function compat(element) {
+	  if (element.type !== 'rule' || !element.parent || // positive .length indicates that this rule contains pseudo
+	  // negative .length indicates that this rule has been already prefixed
+	  element.length < 1) {
+	    return;
+	  }
+
+	  var value = element.value,
+	      parent = element.parent;
+	  var isImplicitRule = element.column === parent.column && element.line === parent.line;
+
+	  while (parent.type !== 'rule') {
+	    parent = parent.parent;
+	    if (!parent) return;
+	  } // short-circuit for the simplest case
+
+
+	  if (element.props.length === 1 && value.charCodeAt(0) !== 58
+	  /* colon */
+	  && !fixedElements.get(parent)) {
+	    return;
+	  } // if this is an implicitly inserted rule (the one eagerly inserted at the each new nested level)
+	  // then the props has already been manipulated beforehand as they that array is shared between it and its "rule parent"
+
+
+	  if (isImplicitRule) {
+	    return;
+	  }
+
+	  fixedElements.set(element, true);
+	  var points = [];
+	  var rules = getRules(value, points);
+	  var parentRules = parent.props;
+
+	  for (var i = 0, k = 0; i < rules.length; i++) {
+	    for (var j = 0; j < parentRules.length; j++, k++) {
+	      element.props[k] = points[i] ? rules[i].replace(/&\f/g, parentRules[j]) : parentRules[j] + " " + rules[i];
+	    }
+	  }
+	};
+	var removeLabel = function removeLabel(element) {
+	  if (element.type === 'decl') {
+	    var value = element.value;
+
+	    if ( // charcode for l
+	    value.charCodeAt(0) === 108 && // charcode for b
+	    value.charCodeAt(2) === 98) {
+	      // this ignores label
+	      element["return"] = '';
+	      element.value = '';
+	    }
+	  }
+	};
+
+	/* eslint-disable no-fallthrough */
+
+	function prefix(value, length) {
+	  switch (hash$2(value, length)) {
+	    // color-adjust
+	    case 5103:
+	      return WEBKIT + 'print-' + value + value;
+	    // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)
+
+	    case 5737:
+	    case 4201:
+	    case 3177:
+	    case 3433:
+	    case 1641:
+	    case 4457:
+	    case 2921: // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break
+
+	    case 5572:
+	    case 6356:
+	    case 5844:
+	    case 3191:
+	    case 6645:
+	    case 3005: // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,
+
+	    case 6391:
+	    case 5879:
+	    case 5623:
+	    case 6135:
+	    case 4599:
+	    case 4855: // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)
+
+	    case 4215:
+	    case 6389:
+	    case 5109:
+	    case 5365:
+	    case 5621:
+	    case 3829:
+	      return WEBKIT + value + value;
+	    // appearance, user-select, transform, hyphens, text-size-adjust
+
+	    case 5349:
+	    case 4246:
+	    case 4810:
+	    case 6968:
+	    case 2756:
+	      return WEBKIT + value + MOZ + value + MS + value + value;
+	    // flex, flex-direction
+
+	    case 6828:
+	    case 4268:
+	      return WEBKIT + value + MS + value + value;
+	    // order
+
+	    case 6165:
+	      return WEBKIT + value + MS + 'flex-' + value + value;
+	    // align-items
+
+	    case 5187:
+	      return WEBKIT + value + replace(value, /(\w+).+(:[^]+)/, WEBKIT + 'box-$1$2' + MS + 'flex-$1$2') + value;
+	    // align-self
+
+	    case 5443:
+	      return WEBKIT + value + MS + 'flex-item-' + replace(value, /flex-|-self/, '') + value;
+	    // align-content
+
+	    case 4675:
+	      return WEBKIT + value + MS + 'flex-line-pack' + replace(value, /align-content|flex-|-self/, '') + value;
+	    // flex-shrink
+
+	    case 5548:
+	      return WEBKIT + value + MS + replace(value, 'shrink', 'negative') + value;
+	    // flex-basis
+
+	    case 5292:
+	      return WEBKIT + value + MS + replace(value, 'basis', 'preferred-size') + value;
+	    // flex-grow
+
+	    case 6060:
+	      return WEBKIT + 'box-' + replace(value, '-grow', '') + WEBKIT + value + MS + replace(value, 'grow', 'positive') + value;
+	    // transition
+
+	    case 4554:
+	      return WEBKIT + replace(value, /([^-])(transform)/g, '$1' + WEBKIT + '$2') + value;
+	    // cursor
+
+	    case 6187:
+	      return replace(replace(replace(value, /(zoom-|grab)/, WEBKIT + '$1'), /(image-set)/, WEBKIT + '$1'), value, '') + value;
+	    // background, background-image
+
+	    case 5495:
+	    case 3959:
+	      return replace(value, /(image-set\([^]*)/, WEBKIT + '$1' + '$`$1');
+	    // justify-content
+
+	    case 4968:
+	      return replace(replace(value, /(.+:)(flex-)?(.*)/, WEBKIT + 'box-pack:$3' + MS + 'flex-pack:$3'), /s.+-b[^;]+/, 'justify') + WEBKIT + value + value;
+	    // (margin|padding)-inline-(start|end)
+
+	    case 4095:
+	    case 3583:
+	    case 4068:
+	    case 2532:
+	      return replace(value, /(.+)-inline(.+)/, WEBKIT + '$1$2') + value;
+	    // (min|max)?(width|height|inline-size|block-size)
+
+	    case 8116:
+	    case 7059:
+	    case 5753:
+	    case 5535:
+	    case 5445:
+	    case 5701:
+	    case 4933:
+	    case 4677:
+	    case 5533:
+	    case 5789:
+	    case 5021:
+	    case 4765:
+	      // stretch, max-content, min-content, fill-available
+	      if (strlen(value) - 1 - length > 6) switch (charat(value, length + 1)) {
+	        // (m)ax-content, (m)in-content
+	        case 109:
+	          // -
+	          if (charat(value, length + 4) !== 45) break;
+	        // (f)ill-available, (f)it-content
+
+	        case 102:
+	          return replace(value, /(.+:)(.+)-([^]+)/, '$1' + WEBKIT + '$2-$3' + '$1' + MOZ + (charat(value, length + 3) == 108 ? '$3' : '$2-$3')) + value;
+	        // (s)tretch
+
+	        case 115:
+	          return ~indexof(value, 'stretch') ? prefix(replace(value, 'stretch', 'fill-available'), length) + value : value;
+	      }
+	      break;
+	    // position: sticky
+
+	    case 4949:
+	      // (s)ticky?
+	      if (charat(value, length + 1) !== 115) break;
+	    // display: (flex|inline-flex)
+
+	    case 6444:
+	      switch (charat(value, strlen(value) - 3 - (~indexof(value, '!important') && 10))) {
+	        // stic(k)y
+	        case 107:
+	          return replace(value, ':', ':' + WEBKIT) + value;
+	        // (inline-)?fl(e)x
+
+	        case 101:
+	          return replace(value, /(.+:)([^;!]+)(;|!.+)?/, '$1' + WEBKIT + (charat(value, 14) === 45 ? 'inline-' : '') + 'box$3' + '$1' + WEBKIT + '$2$3' + '$1' + MS + '$2box$3') + value;
+	      }
+
+	      break;
+	    // writing-mode
+
+	    case 5936:
+	      switch (charat(value, length + 11)) {
+	        // vertical-l(r)
+	        case 114:
+	          return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, 'tb') + value;
+	        // vertical-r(l)
+
+	        case 108:
+	          return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, 'tb-rl') + value;
+	        // horizontal(-)tb
+
+	        case 45:
+	          return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, 'lr') + value;
+	      }
+
+	      return WEBKIT + value + MS + value + value;
+	  }
+
+	  return value;
+	}
+
+	var prefixer = function prefixer(element, index, children, callback) {
+	  if (element.length > -1) if (!element["return"]) switch (element.type) {
+	    case DECLARATION:
+	      element["return"] = prefix(element.value, element.length);
+	      break;
+
+	    case KEYFRAMES:
+	      return serialize([copy(element, {
+	        value: replace(element.value, '@', '@' + WEBKIT)
+	      })], callback);
+
+	    case RULESET:
+	      if (element.length) return combine(element.props, function (value) {
+	        switch (match(value, /(::plac\w+|:read-\w+)/)) {
+	          // :read-(only|write)
+	          case ':read-only':
+	          case ':read-write':
+	            return serialize([copy(element, {
+	              props: [replace(value, /:(read-\w+)/, ':' + MOZ + '$1')]
+	            })], callback);
+	          // :placeholder
+
+	          case '::placeholder':
+	            return serialize([copy(element, {
+	              props: [replace(value, /:(plac\w+)/, ':' + WEBKIT + 'input-$1')]
+	            }), copy(element, {
+	              props: [replace(value, /:(plac\w+)/, ':' + MOZ + '$1')]
+	            }), copy(element, {
+	              props: [replace(value, /:(plac\w+)/, MS + 'input-$1')]
+	            })], callback);
+	        }
+
+	        return '';
+	      });
+	  }
+	};
+
+	var defaultStylisPlugins = [prefixer];
+
+	var createCache = function
+	  /*: EmotionCache */
+	createCache(options
+	/*: Options */
+	) {
+	  var key = options.key;
+
+	  if (key === 'css') {
+	    var ssrStyles = document.querySelectorAll("style[data-emotion]:not([data-s])"); // get SSRed styles out of the way of React's hydration
+	    // document.head is a safe place to move them to(though note document.head is not necessarily the last place they will be)
+	    // note this very very intentionally targets all style elements regardless of the key to ensure
+	    // that creating a cache works inside of render of a React component
+
+	    Array.prototype.forEach.call(ssrStyles, function (node
+	    /*: HTMLStyleElement */
+	    ) {
+	      // we want to only move elements which have a space in the data-emotion attribute value
+	      // because that indicates that it is an Emotion 11 server-side rendered style elements
+	      // while we will already ignore Emotion 11 client-side inserted styles because of the :not([data-s]) part in the selector
+	      // Emotion 10 client-side inserted styles did not have data-s (but importantly did not have a space in their data-emotion attributes)
+	      // so checking for the space ensures that loading Emotion 11 after Emotion 10 has inserted some styles
+	      // will not result in the Emotion 10 styles being destroyed
+	      var dataEmotionAttribute = node.getAttribute('data-emotion');
+
+	      if (dataEmotionAttribute.indexOf(' ') === -1) {
+	        return;
+	      }
+
+	      document.head.appendChild(node);
+	      node.setAttribute('data-s', '');
+	    });
+	  }
+
+	  var stylisPlugins = options.stylisPlugins || defaultStylisPlugins;
+
+	  var inserted = {};
+	  var container;
+	  /* : Node */
+
+	  var nodesToHydrate = [];
+
+	  {
+	    container = options.container || document.head;
+	    Array.prototype.forEach.call( // this means we will ignore elements which don't have a space in them which
+	    // means that the style elements we're looking at are only Emotion 11 server-rendered style elements
+	    document.querySelectorAll("style[data-emotion^=\"" + key + " \"]"), function (node
+	    /*: HTMLStyleElement */
+	    ) {
+	      var attrib = node.getAttribute("data-emotion").split(' ');
+
+	      for (var i = 1; i < attrib.length; i++) {
+	        inserted[attrib[i]] = true;
+	      }
+
+	      nodesToHydrate.push(node);
+	    });
+	  }
+
+	  var _insert;
+	  /*: (
+	  selector: string,
+	  serialized: SerializedStyles,
+	  sheet: StyleSheet,
+	  shouldCache: boolean
+	  ) => string | void */
+
+
+	  var omnipresentPlugins = [compat, removeLabel];
+
+	  {
+	    var currentSheet;
+	    var finalizingPlugins = [stringify, rulesheet(function (rule) {
+	      currentSheet.insert(rule);
+	    })];
+	    var serializer = middleware(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins));
+
+	    var stylis = function stylis(styles) {
+	      return serialize(compile(styles), serializer);
+	    };
+
+	    _insert = function
+	      /*: void */
+	    insert(selector
+	    /*: string */
+	    , serialized
+	    /*: SerializedStyles */
+	    , sheet
+	    /*: StyleSheet */
+	    , shouldCache
+	    /*: boolean */
+	    ) {
+	      currentSheet = sheet;
+
+	      stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);
+
+	      if (shouldCache) {
+	        cache.inserted[serialized.name] = true;
+	      }
+	    };
+	  }
+
+	  var cache
+	  /*: EmotionCache */
+	  = {
+	    key: key,
+	    sheet: new StyleSheet({
+	      key: key,
+	      container: container,
+	      nonce: options.nonce,
+	      speedy: options.speedy,
+	      prepend: options.prepend,
+	      insertionPoint: options.insertionPoint
+	    }),
+	    nonce: options.nonce,
+	    inserted: inserted,
+	    registered: {},
+	    insert: _insert
+	  };
+	  cache.sheet.hydrate(nodesToHydrate);
+	  return cache;
+	};
+
 	var jsxRuntime = {exports: {}};
 
 	var reactJsxRuntime_production_min = {};
@@ -10686,7 +11147,7 @@
 	};
 	const ClassNameGenerator = createClassNameGenerator();
 
-	function r$1(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r$1(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r$1(e))&&(n&&(n+=" "),n+=t);return n}
+	function r$2(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r$2(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx$1(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r$2(e))&&(n&&(n+=" "),n+=t);return n}
 
 	const _excluded$P = ["className", "component"];
 	function createBox(options = {}) {
@@ -10710,7 +11171,7 @@
 	    return /*#__PURE__*/jsxRuntimeExports.jsx(BoxRoot, _extends$1({
 	      as: component,
 	      ref: ref,
-	      className: clsx(className, generateClassName ? generateClassName(defaultClassName) : defaultClassName),
+	      className: clsx$1(className, generateClassName ? generateClassName(defaultClassName) : defaultClassName),
 	      theme: themeId ? theme[themeId] || theme : theme
 	    }, other));
 	  });
@@ -11569,6 +12030,8 @@
 	  });
 	}
 
+	function r$1(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r$1(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r$1(e))&&(n&&(n+=" "),n+=t);return n}
+
 	/**
 	 * Extracts event handlers from a given object.
 	 * A prop is considered an event handler if it is a function and its name starts with `on`.
@@ -12078,7 +12541,7 @@
 	      as: component,
 	      ownerState: ownerState,
 	      ref: ref,
-	      className: clsx(classes.root, className)
+	      className: clsx$1(classes.root, className)
 	    }, other, {
 	      children: divider ? joinChildren(children, divider) : children
 	    }));
@@ -14207,14 +14670,14 @@
 	    timeout
 	  } = props;
 	  const [leaving, setLeaving] = reactExports.useState(false);
-	  const rippleClassName = clsx(className, classes.ripple, classes.rippleVisible, pulsate && classes.ripplePulsate);
+	  const rippleClassName = clsx$1(className, classes.ripple, classes.rippleVisible, pulsate && classes.ripplePulsate);
 	  const rippleStyles = {
 	    width: rippleSize,
 	    height: rippleSize,
 	    top: -(rippleSize / 2) + rippleY,
 	    left: -(rippleSize / 2) + rippleX
 	  };
-	  const childClassName = clsx(classes.child, leaving && classes.childLeaving, pulsate && classes.childPulsate);
+	  const childClassName = clsx$1(classes.child, leaving && classes.childLeaving, pulsate && classes.childPulsate);
 	  if (!inProp && !leaving) {
 	    setLeaving(true);
 	  }
@@ -14398,12 +14861,12 @@
 	    } = params;
 	    setRipples(oldRipples => [...oldRipples, /*#__PURE__*/jsxRuntimeExports.jsx(TouchRippleRipple, {
 	      classes: {
-	        ripple: clsx(classes.ripple, touchRippleClasses.ripple),
-	        rippleVisible: clsx(classes.rippleVisible, touchRippleClasses.rippleVisible),
-	        ripplePulsate: clsx(classes.ripplePulsate, touchRippleClasses.ripplePulsate),
-	        child: clsx(classes.child, touchRippleClasses.child),
-	        childLeaving: clsx(classes.childLeaving, touchRippleClasses.childLeaving),
-	        childPulsate: clsx(classes.childPulsate, touchRippleClasses.childPulsate)
+	        ripple: clsx$1(classes.ripple, touchRippleClasses.ripple),
+	        rippleVisible: clsx$1(classes.rippleVisible, touchRippleClasses.rippleVisible),
+	        ripplePulsate: clsx$1(classes.ripplePulsate, touchRippleClasses.ripplePulsate),
+	        child: clsx$1(classes.child, touchRippleClasses.child),
+	        childLeaving: clsx$1(classes.childLeaving, touchRippleClasses.childLeaving),
+	        childPulsate: clsx$1(classes.childPulsate, touchRippleClasses.childPulsate)
 	      },
 	      timeout: DURATION,
 	      pulsate: pulsate,
@@ -14531,7 +14994,7 @@
 	    stop
 	  }), [pulsate, start, stop]);
 	  return /*#__PURE__*/jsxRuntimeExports.jsx(TouchRippleRoot, _extends$1({
-	    className: clsx(touchRippleClasses.root, classes.root, className),
+	    className: clsx$1(touchRippleClasses.root, classes.root, className),
 	    ref: container
 	  }, other, {
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx(TransitionGroup, {
@@ -14810,7 +15273,7 @@
 	  const classes = useUtilityClasses$r(ownerState);
 	  return /*#__PURE__*/jsxRuntimeExports.jsxs(ButtonBaseRoot, _extends$1({
 	    as: ComponentProp,
-	    className: clsx(classes.root, className),
+	    className: clsx$1(classes.root, className),
 	    ownerState: ownerState,
 	    onBlur: handleBlur,
 	    onClick: onClick,
@@ -15107,11 +15570,11 @@
 	  const positionClassName = buttonGroupButtonContextPositionClassName || '';
 	  return /*#__PURE__*/jsxRuntimeExports.jsxs(ButtonRoot, _extends$1({
 	    ownerState: ownerState,
-	    className: clsx(contextProps.className, classes.root, className, positionClassName),
+	    className: clsx$1(contextProps.className, classes.root, className, positionClassName),
 	    component: component,
 	    disabled: disabled,
 	    focusRipple: !disableFocusRipple,
-	    focusVisibleClassName: clsx(classes.focusVisible, focusVisibleClassName),
+	    focusVisibleClassName: clsx$1(classes.focusVisible, focusVisibleClassName),
 	    ref: ref,
 	    type: type
 	  }, other, {
@@ -15449,7 +15912,7 @@
 	  return cache$1[key];
 	}
 
-	const NEBULA_VERSION_HASH = "3b94";
+	const NEBULA_VERSION_HASH = "3efc";
 	ClassNameGenerator.configure(componentName => {
 	  return "njs-".concat(NEBULA_VERSION_HASH, "-").concat(componentName.replace('Mui', ''));
 	});
@@ -15693,7 +16156,7 @@
 	  const appRef = React.createRef();
 	  const element = document.createElement('div');
 	  element.style.display = 'none';
-	  element.setAttribute('data-nebulajs-version', "6.0.0-alpha.1");
+	  element.setAttribute('data-nebulajs-version', "6.0.0-alpha.2");
 	  element.setAttribute('data-app-id', app.id);
 	  document.body.appendChild(element);
 	  if (context) {
@@ -15868,7 +16331,7 @@
 	  const classes = useUtilityClasses$p(ownerState);
 	  return /*#__PURE__*/jsxRuntimeExports.jsxs(SvgIconRoot, _extends$1({
 	    as: component,
-	    className: clsx(classes.root, className),
+	    className: clsx$1(classes.root, className),
 	    focusable: "false",
 	    color: htmlColor,
 	    "aria-hidden": titleAccess ? undefined : true,
@@ -16012,7 +16475,7 @@
 	  return /*#__PURE__*/jsxRuntimeExports.jsx(PaperRoot, _extends$1({
 	    as: component,
 	    ownerState: ownerState,
-	    className: clsx(classes.root, className),
+	    className: clsx$1(classes.root, className),
 	    ref: ref
 	  }, other));
 	});
@@ -16133,7 +16596,7 @@
 	  });
 	  const classes = useUtilityClasses$n(ownerState);
 	  return /*#__PURE__*/jsxRuntimeExports.jsx(IconButtonRoot, _extends$1({
-	    className: clsx(classes.root, className),
+	    className: clsx$1(classes.root, className),
 	    centerRipple: true,
 	    focusRipple: !disableFocusRipple,
 	    disabled: disabled,
@@ -16254,7 +16717,7 @@
 	    as: Component,
 	    ref: ref,
 	    ownerState: ownerState,
-	    className: clsx(classes.root, className)
+	    className: clsx$1(classes.root, className)
 	  }, other));
 	});
 
@@ -19086,7 +19549,7 @@
 	      ref: ref,
 	      onClick: handleClick
 	    }, other, {
-	      className: clsx(classes.root, rootProps.className, className, readOnly && 'MuiInputBase-readOnly'),
+	      className: clsx$1(classes.root, rootProps.className, className, readOnly && 'MuiInputBase-readOnly'),
 	      children: [startAdornment, /*#__PURE__*/jsxRuntimeExports.jsx(FormControlContext.Provider, {
 	        value: null,
 	        children: /*#__PURE__*/jsxRuntimeExports.jsx(Input, _extends$1({
@@ -19113,7 +19576,7 @@
 	          ownerState: _extends$1({}, ownerState, inputProps.ownerState)
 	        }, {
 	          ref: handleInputRef,
-	          className: clsx(classes.input, inputProps.className, readOnly && 'MuiInputBase-readOnly'),
+	          className: clsx$1(classes.input, inputProps.className, readOnly && 'MuiInputBase-readOnly'),
 	          onBlur: handleBlur,
 	          onChange: handleChange,
 	          onFocus: handleFocus
@@ -19322,7 +19785,7 @@
 	      "aria-hidden": true
 	    }, rootSlotProps, {
 	      as: (_ref = (_slots$root = slots.root) != null ? _slots$root : components.Root) != null ? _ref : component,
-	      className: clsx(classes.root, className, rootSlotProps == null ? void 0 : rootSlotProps.className),
+	      className: clsx$1(classes.root, className, rootSlotProps == null ? void 0 : rootSlotProps.className),
 	      ownerState: _extends$1({}, ownerState, rootSlotProps == null ? void 0 : rootSlotProps.ownerState),
 	      classes: classes,
 	      ref: ref,
@@ -19659,13 +20122,13 @@
 	      as: component
 	    },
 	    ownerState,
-	    className: clsx(rootSlotProps == null ? void 0 : rootSlotProps.className, classes.root, className)
+	    className: clsx$1(rootSlotProps == null ? void 0 : rootSlotProps.className, classes.root, className)
 	  });
 	  const badgeProps = useSlotProps({
 	    elementType: BadgeSlot,
 	    externalSlotProps: badgeSlotProps,
 	    ownerState,
-	    className: clsx(classes.badge, badgeSlotProps == null ? void 0 : badgeSlotProps.className)
+	    className: clsx$1(classes.badge, badgeSlotProps == null ? void 0 : badgeSlotProps.className)
 	  });
 	  return /*#__PURE__*/jsxRuntimeExports.jsxs(RootSlot, _extends$1({}, rootProps, {
 	    children: [children, /*#__PURE__*/jsxRuntimeExports.jsx(BadgeSlot, _extends$1({}, badgeProps, {
@@ -19810,7 +20273,7 @@
 	  const classes = useUtilityClasses$h(ownerState);
 	  return /*#__PURE__*/jsxRuntimeExports.jsxs(SwitchBaseRoot, _extends$1({
 	    component: "span",
-	    className: clsx(classes.root, className),
+	    className: clsx$1(classes.root, className),
 	    centerRipple: true,
 	    focusRipple: !disableFocusRipple,
 	    disabled: disabled,
@@ -19945,7 +20408,7 @@
 	    }),
 	    ownerState: ownerState,
 	    ref: ref,
-	    className: clsx(classes.root, className)
+	    className: clsx$1(classes.root, className)
 	  }, other, {
 	    classes: classes
 	  }));
@@ -20101,7 +20564,7 @@
 	    rootStyle.transform = 'rotate(-90deg)';
 	  }
 	  return /*#__PURE__*/jsxRuntimeExports.jsx(CircularProgressRoot, _extends$1({
-	    className: clsx(classes.root, className),
+	    className: clsx$1(classes.root, className),
 	    style: _extends$1({
 	      width: size,
 	      height: size
@@ -20939,7 +21402,7 @@
 	      as: component
 	    },
 	    ownerState,
-	    className: clsx(className, rootSlotProps == null ? void 0 : rootSlotProps.className, classes == null ? void 0 : classes.root, !ownerState.open && ownerState.exited && (classes == null ? void 0 : classes.hidden))
+	    className: clsx$1(className, rootSlotProps == null ? void 0 : rootSlotProps.className, classes == null ? void 0 : classes.root, !ownerState.open && ownerState.exited && (classes == null ? void 0 : classes.hidden))
 	  });
 	  const backdropProps = useSlotProps({
 	    elementType: BackdropSlot,
@@ -20957,7 +21420,7 @@
 	        }
 	      }));
 	    },
-	    className: clsx(backdropSlotProps == null ? void 0 : backdropSlotProps.className, BackdropProps == null ? void 0 : BackdropProps.className, classes == null ? void 0 : classes.backdrop),
+	    className: clsx$1(backdropSlotProps == null ? void 0 : backdropSlotProps.className, BackdropProps == null ? void 0 : BackdropProps.className, classes == null ? void 0 : classes.backdrop),
 	    ownerState
 	  });
 	  if (!keepMounted && !open && (!hasTransition || exited)) {
@@ -21145,7 +21608,7 @@
 	  const classes = useUtilityClasses$d(ownerState);
 	  return /*#__PURE__*/jsxRuntimeExports.jsx(DividerRoot, _extends$1({
 	    as: component,
-	    className: clsx(classes.root, className),
+	    className: clsx$1(classes.root, className),
 	    role: role,
 	    ref: ref,
 	    ownerState: ownerState
@@ -21306,12 +21769,12 @@
 	    label = /*#__PURE__*/jsxRuntimeExports.jsx(Typography, _extends$1({
 	      component: "span"
 	    }, typographySlotProps, {
-	      className: clsx(classes.label, typographySlotProps == null ? void 0 : typographySlotProps.className),
+	      className: clsx$1(classes.label, typographySlotProps == null ? void 0 : typographySlotProps.className),
 	      children: label
 	    }));
 	  }
 	  return /*#__PURE__*/jsxRuntimeExports.jsxs(FormControlLabelRoot, _extends$1({
-	    className: clsx(classes.root, className),
+	    className: clsx$1(classes.root, className),
 	    ownerState: ownerState,
 	    ref: ref
 	  }, other, {
@@ -21742,7 +22205,7 @@
 	    value: columns,
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx(GridRoot, _extends$1({
 	      ownerState: ownerState,
-	      className: clsx(classes.root, className),
+	      className: clsx$1(classes.root, className),
 	      as: component,
 	      ref: ref
 	    }, otherFiltered))
@@ -21999,7 +22462,7 @@
 	  const classes = useUtilityClasses$a(ownerState);
 	  return /*#__PURE__*/jsxRuntimeExports.jsx(IconRoot, _extends$1({
 	    as: Component,
-	    className: clsx(baseClassName,
+	    className: clsx$1(baseClassName,
 	    // Prevent the translation of the text content.
 	    // The font relies on the exact text content to render the icon.
 	    'notranslate', classes.root, className),
@@ -22101,7 +22564,7 @@
 	    children: /*#__PURE__*/jsxRuntimeExports.jsx(InputAdornmentRoot, _extends$1({
 	      as: component,
 	      ownerState: ownerState,
-	      className: clsx(classes.root, className),
+	      className: clsx$1(classes.root, className),
 	      ref: ref
 	    }, other, {
 	      children: typeof children === 'string' && !disableTypography ? /*#__PURE__*/jsxRuntimeExports.jsx(Typography, {
@@ -22189,7 +22652,7 @@
 	    value: context,
 	    children: /*#__PURE__*/jsxRuntimeExports.jsxs(ListRoot, _extends$1({
 	      as: component,
-	      className: clsx(classes.root, className),
+	      className: clsx$1(classes.root, className),
 	      ref: ref,
 	      ownerState: ownerState
 	    }, other, {
@@ -22259,7 +22722,7 @@
 	  });
 	  const classes = useUtilityClasses$7(ownerState);
 	  return /*#__PURE__*/jsxRuntimeExports.jsx(ListItemSecondaryActionRoot, _extends$1({
-	    className: clsx(classes.root, className),
+	    className: clsx$1(classes.root, className),
 	    ownerState: ownerState,
 	    ref: ref
 	  }, other));
@@ -22445,13 +22908,13 @@
 	  const Root = slots.root || components.Root || ListItemRoot;
 	  const rootProps = slotProps.root || componentsProps.root || {};
 	  const componentProps = _extends$1({
-	    className: clsx(classes.root, rootProps.className, className),
+	    className: clsx$1(classes.root, rootProps.className, className),
 	    disabled
 	  }, other);
 	  let Component = componentProp || 'li';
 	  if (button) {
 	    componentProps.component = componentProp || 'div';
-	    componentProps.focusVisibleClassName = clsx(listItemClasses.focusVisible, focusVisibleClassName);
+	    componentProps.focusVisibleClassName = clsx$1(listItemClasses.focusVisible, focusVisibleClassName);
 	    Component = ButtonBase;
 	  }
 
@@ -22472,7 +22935,7 @@
 	      value: childContext,
 	      children: /*#__PURE__*/jsxRuntimeExports.jsxs(ListItemContainer, _extends$1({
 	        as: ContainerComponent,
-	        className: clsx(classes.container, ContainerClassName),
+	        className: clsx$1(classes.container, ContainerClassName),
 	        ref: handleRef,
 	        ownerState: ownerState
 	      }, ContainerProps, {
@@ -22555,7 +23018,7 @@
 	  });
 	  const classes = useUtilityClasses$5(ownerState);
 	  return /*#__PURE__*/jsxRuntimeExports.jsx(ListItemIconRoot, _extends$1({
-	    className: clsx(classes.root, className),
+	    className: clsx$1(classes.root, className),
 	    ownerState: ownerState,
 	    ref: ref
 	  }, other));
@@ -23066,7 +23529,7 @@
 	      ref: handlePaperRef
 	    },
 	    ownerState,
-	    className: clsx(classes.paper, externalPaperSlotProps == null ? void 0 : externalPaperSlotProps.className)
+	    className: clsx$1(classes.paper, externalPaperSlotProps == null ? void 0 : externalPaperSlotProps.className)
 	  });
 	  const _useSlotProps = useSlotProps({
 	      elementType: RootSlot,
@@ -23083,7 +23546,7 @@
 	        open
 	      },
 	      ownerState,
-	      className: clsx(classes.root, className)
+	      className: clsx$1(classes.root, className)
 	    }),
 	    {
 	      slotProps: rootSlotPropsProp
@@ -23266,8 +23729,8 @@
 	      role: role,
 	      tabIndex: tabIndex,
 	      component: component,
-	      focusVisibleClassName: clsx(classes.focusVisible, focusVisibleClassName),
-	      className: clsx(classes.root, className)
+	      focusVisibleClassName: clsx$1(classes.focusVisible, focusVisibleClassName),
+	      className: clsx$1(classes.root, className)
 	    }, other, {
 	      ownerState: ownerState,
 	      classes: classes
@@ -23733,7 +24196,7 @@
 	    checked: checked,
 	    onChange: onChange,
 	    ref: ref,
-	    className: clsx(classes.root, className)
+	    className: clsx$1(classes.root, className)
 	  }, other));
 	});
 
@@ -24160,7 +24623,7 @@
 	    nameOrDescProps['aria-labelledby'] = open && !titleIsString ? id : null;
 	  }
 	  const childrenProps = _extends$1({}, nameOrDescProps, other, children.props, {
-	    className: clsx(other.className, children.props.className),
+	    className: clsx$1(other.className, children.props.className),
 	    onTouchStart: detectTouchStart,
 	    ref: handleRef
 	  }, followCursor ? {
@@ -24218,14 +24681,14 @@
 	  const TooltipComponent = (_ref4 = (_slots$tooltip = slots.tooltip) != null ? _slots$tooltip : components.Tooltip) != null ? _ref4 : TooltipTooltip;
 	  const ArrowComponent = (_ref5 = (_slots$arrow = slots.arrow) != null ? _slots$arrow : components.Arrow) != null ? _ref5 : TooltipArrow;
 	  const popperProps = appendOwnerState(PopperComponent, _extends$1({}, PopperProps, (_slotProps$popper = slotProps.popper) != null ? _slotProps$popper : componentsProps.popper, {
-	    className: clsx(classes.popper, PopperProps == null ? void 0 : PopperProps.className, (_ref6 = (_slotProps$popper2 = slotProps.popper) != null ? _slotProps$popper2 : componentsProps.popper) == null ? void 0 : _ref6.className)
+	    className: clsx$1(classes.popper, PopperProps == null ? void 0 : PopperProps.className, (_ref6 = (_slotProps$popper2 = slotProps.popper) != null ? _slotProps$popper2 : componentsProps.popper) == null ? void 0 : _ref6.className)
 	  }), ownerState);
 	  const transitionProps = appendOwnerState(TransitionComponent, _extends$1({}, TransitionProps, (_slotProps$transition = slotProps.transition) != null ? _slotProps$transition : componentsProps.transition), ownerState);
 	  const tooltipProps = appendOwnerState(TooltipComponent, _extends$1({}, (_slotProps$tooltip = slotProps.tooltip) != null ? _slotProps$tooltip : componentsProps.tooltip, {
-	    className: clsx(classes.tooltip, (_ref7 = (_slotProps$tooltip2 = slotProps.tooltip) != null ? _slotProps$tooltip2 : componentsProps.tooltip) == null ? void 0 : _ref7.className)
+	    className: clsx$1(classes.tooltip, (_ref7 = (_slotProps$tooltip2 = slotProps.tooltip) != null ? _slotProps$tooltip2 : componentsProps.tooltip) == null ? void 0 : _ref7.className)
 	  }), ownerState);
 	  const tooltipArrowProps = appendOwnerState(ArrowComponent, _extends$1({}, (_slotProps$arrow = slotProps.arrow) != null ? _slotProps$arrow : componentsProps.arrow, {
-	    className: clsx(classes.arrow, (_ref8 = (_slotProps$arrow2 = slotProps.arrow) != null ? _slotProps$arrow2 : componentsProps.arrow) == null ? void 0 : _ref8.className)
+	    className: clsx$1(classes.arrow, (_ref8 = (_slotProps$arrow2 = slotProps.arrow) != null ? _slotProps$arrow2 : componentsProps.arrow) == null ? void 0 : _ref8.className)
 	  }), ownerState);
 	  return /*#__PURE__*/jsxRuntimeExports.jsxs(reactExports.Fragment, {
 	    children: [/*#__PURE__*/reactExports.cloneElement(children, childrenProps), /*#__PURE__*/jsxRuntimeExports.jsx(PopperComponent, _extends$1({
@@ -42440,1625 +42903,1357 @@
 
 	var lrucache;
 	var hasRequiredLrucache;
-
-	function requireLrucache () {
-		if (hasRequiredLrucache) return lrucache;
-		hasRequiredLrucache = 1;
-
-		class LRUCache {
-		  constructor () {
-		    this.max = 1000;
-		    this.map = new Map();
-		  }
-
-		  get (key) {
-		    const value = this.map.get(key);
-		    if (value === undefined) {
-		      return undefined
-		    } else {
-		      // Remove the key from the map and add it to the end
-		      this.map.delete(key);
-		      this.map.set(key, value);
-		      return value
-		    }
-		  }
-
-		  delete (key) {
-		    return this.map.delete(key)
-		  }
-
-		  set (key, value) {
-		    const deleted = this.delete(key);
-
-		    if (!deleted && value !== undefined) {
-		      // If cache is full, delete the least recently used item
-		      if (this.map.size >= this.max) {
-		        const firstKey = this.map.keys().next().value;
-		        this.delete(firstKey);
-		      }
-
-		      this.map.set(key, value);
-		    }
-
-		    return this
-		  }
-		}
-
-		lrucache = LRUCache;
-		return lrucache;
+	function requireLrucache() {
+	  if (hasRequiredLrucache) return lrucache;
+	  hasRequiredLrucache = 1;
+	  class LRUCache {
+	    constructor() {
+	      this.max = 1000;
+	      this.map = new Map();
+	    }
+	    get(key) {
+	      const value = this.map.get(key);
+	      if (value === undefined) {
+	        return undefined;
+	      } else {
+	        // Remove the key from the map and add it to the end
+	        this.map.delete(key);
+	        this.map.set(key, value);
+	        return value;
+	      }
+	    }
+	    delete(key) {
+	      return this.map.delete(key);
+	    }
+	    set(key, value) {
+	      const deleted = this.delete(key);
+	      if (!deleted && value !== undefined) {
+	        // If cache is full, delete the least recently used item
+	        if (this.map.size >= this.max) {
+	          const firstKey = this.map.keys().next().value;
+	          this.delete(firstKey);
+	        }
+	        this.map.set(key, value);
+	      }
+	      return this;
+	    }
+	  }
+	  lrucache = LRUCache;
+	  return lrucache;
 	}
 
 	var parseOptions_1;
 	var hasRequiredParseOptions;
+	function requireParseOptions() {
+	  if (hasRequiredParseOptions) return parseOptions_1;
+	  hasRequiredParseOptions = 1;
 
-	function requireParseOptions () {
-		if (hasRequiredParseOptions) return parseOptions_1;
-		hasRequiredParseOptions = 1;
-
-		// parse out just the options we care about
-		const looseOption = Object.freeze({ loose: true });
-		const emptyOpts = Object.freeze({ });
-		const parseOptions = options => {
-		  if (!options) {
-		    return emptyOpts
-		  }
-
-		  if (typeof options !== 'object') {
-		    return looseOption
-		  }
-
-		  return options
-		};
-		parseOptions_1 = parseOptions;
-		return parseOptions_1;
+	  // parse out just the options we care about
+	  const looseOption = Object.freeze({
+	    loose: true
+	  });
+	  const emptyOpts = Object.freeze({});
+	  const parseOptions = options => {
+	    if (!options) {
+	      return emptyOpts;
+	    }
+	    if (typeof options !== 'object') {
+	      return looseOption;
+	    }
+	    return options;
+	  };
+	  parseOptions_1 = parseOptions;
+	  return parseOptions_1;
 	}
 
 	var re = {exports: {}};
 
 	var constants;
 	var hasRequiredConstants;
-
-	function requireConstants () {
-		if (hasRequiredConstants) return constants;
-		hasRequiredConstants = 1;
-
-		// Note: this is the semver.org version of the spec that it implements
-		// Not necessarily the package version of this code.
-		const SEMVER_SPEC_VERSION = '2.0.0';
-
-		const MAX_LENGTH = 256;
-		const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
-		/* istanbul ignore next */ 9007199254740991;
-
-		// Max safe segment length for coercion.
-		const MAX_SAFE_COMPONENT_LENGTH = 16;
-
-		// Max safe length for a build identifier. The max length minus 6 characters for
-		// the shortest version with a build 0.0.0+BUILD.
-		const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
-
-		const RELEASE_TYPES = [
-		  'major',
-		  'premajor',
-		  'minor',
-		  'preminor',
-		  'patch',
-		  'prepatch',
-		  'prerelease',
-		];
-
-		constants = {
-		  MAX_LENGTH,
-		  MAX_SAFE_COMPONENT_LENGTH,
-		  MAX_SAFE_BUILD_LENGTH,
-		  MAX_SAFE_INTEGER,
-		  RELEASE_TYPES,
-		  SEMVER_SPEC_VERSION,
-		  FLAG_INCLUDE_PRERELEASE: 0b001,
-		  FLAG_LOOSE: 0b010,
-		};
-		return constants;
+	function requireConstants() {
+	  if (hasRequiredConstants) return constants;
+	  hasRequiredConstants = 1;
+
+	  // Note: this is the semver.org version of the spec that it implements
+	  // Not necessarily the package version of this code.
+	  const SEMVER_SPEC_VERSION = '2.0.0';
+	  const MAX_LENGTH = 256;
+	  const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */9007199254740991;
+
+	  // Max safe segment length for coercion.
+	  const MAX_SAFE_COMPONENT_LENGTH = 16;
+
+	  // Max safe length for a build identifier. The max length minus 6 characters for
+	  // the shortest version with a build 0.0.0+BUILD.
+	  const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+	  const RELEASE_TYPES = ['major', 'premajor', 'minor', 'preminor', 'patch', 'prepatch', 'prerelease'];
+	  constants = {
+	    MAX_LENGTH,
+	    MAX_SAFE_COMPONENT_LENGTH,
+	    MAX_SAFE_BUILD_LENGTH,
+	    MAX_SAFE_INTEGER,
+	    RELEASE_TYPES,
+	    SEMVER_SPEC_VERSION,
+	    FLAG_INCLUDE_PRERELEASE: 0b001,
+	    FLAG_LOOSE: 0b010
+	  };
+	  return constants;
 	}
 
 	var debug_1;
 	var hasRequiredDebug;
-
-	function requireDebug () {
-		if (hasRequiredDebug) return debug_1;
-		hasRequiredDebug = 1;
-
-		const debug = (
-		  typeof process === 'object' &&
-		  process.env &&
-		  process.env.NODE_DEBUG &&
-		  /\bsemver\b/i.test(process.env.NODE_DEBUG)
-		) ? (...args) => console.error('SEMVER', ...args)
-		  : () => {};
-
-		debug_1 = debug;
-		return debug_1;
+	function requireDebug() {
+	  if (hasRequiredDebug) return debug_1;
+	  hasRequiredDebug = 1;
+	  const debug = typeof process === 'object' && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? function () {
+	    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+	      args[_key] = arguments[_key];
+	    }
+	    return console.error('SEMVER', ...args);
+	  } : () => {};
+	  debug_1 = debug;
+	  return debug_1;
 	}
 
 	var hasRequiredRe;
+	function requireRe() {
+	  if (hasRequiredRe) return re.exports;
+	  hasRequiredRe = 1;
+	  (function (module, exports) {
 
-	function requireRe () {
-		if (hasRequiredRe) return re.exports;
-		hasRequiredRe = 1;
-		(function (module, exports) {
-
-			const {
-			  MAX_SAFE_COMPONENT_LENGTH,
-			  MAX_SAFE_BUILD_LENGTH,
-			  MAX_LENGTH,
-			} = requireConstants();
-			const debug = requireDebug();
-			exports = module.exports = {};
-
-			// The actual regexps go on exports.re
-			const re = exports.re = [];
-			const safeRe = exports.safeRe = [];
-			const src = exports.src = [];
-			const safeSrc = exports.safeSrc = [];
-			const t = exports.t = {};
-			let R = 0;
-
-			const LETTERDASHNUMBER = '[a-zA-Z0-9-]';
-
-			// Replace some greedy regex tokens to prevent regex dos issues. These regex are
-			// used internally via the safeRe object since all inputs in this library get
-			// normalized first to trim and collapse all extra whitespace. The original
-			// regexes are exported for userland consumption and lower level usage. A
-			// future breaking change could export the safer regex only with a note that
-			// all input should have extra whitespace removed.
-			const safeRegexReplacements = [
-			  ['\\s', 1],
-			  ['\\d', MAX_LENGTH],
-			  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
-			];
-
-			const makeSafeRegex = (value) => {
-			  for (const [token, max] of safeRegexReplacements) {
-			    value = value
-			      .split(`${token}*`).join(`${token}{0,${max}}`)
-			      .split(`${token}+`).join(`${token}{1,${max}}`);
-			  }
-			  return value
-			};
-
-			const createToken = (name, value, isGlobal) => {
-			  const safe = makeSafeRegex(value);
-			  const index = R++;
-			  debug(name, index, value);
-			  t[name] = index;
-			  src[index] = value;
-			  safeSrc[index] = safe;
-			  re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
-			  safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined);
-			};
-
-			// The following Regular Expressions can be used for tokenizing,
-			// validating, and parsing SemVer version strings.
-
-			// ## Numeric Identifier
-			// A single `0`, or a non-zero digit followed by zero or more digits.
-
-			createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
-			createToken('NUMERICIDENTIFIERLOOSE', '\\d+');
-
-			// ## Non-numeric Identifier
-			// Zero or more digits, followed by a letter or hyphen, and then zero or
-			// more letters, digits, or hyphens.
-
-			createToken('NONNUMERICIDENTIFIER', `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
-
-			// ## Main Version
-			// Three dot-separated numeric identifiers.
-
-			createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
-			                   `(${src[t.NUMERICIDENTIFIER]})\\.` +
-			                   `(${src[t.NUMERICIDENTIFIER]})`);
-
-			createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
-			                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
-			                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
-
-			// ## Pre-release Version Identifier
-			// A numeric identifier, or a non-numeric identifier.
-			// Non-numberic identifiers include numberic identifiers but can be longer.
-			// Therefore non-numberic identifiers must go first.
-
-			createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NONNUMERICIDENTIFIER]
-		}|${src[t.NUMERICIDENTIFIER]})`);
-
-			createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NONNUMERICIDENTIFIER]
-		}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
-
-			// ## Pre-release Version
-			// Hyphen, followed by one or more dot-separated pre-release version
-			// identifiers.
-
-			createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
-		}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
-
-			createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
-		}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
-
-			// ## Build Metadata Identifier
-			// Any combination of digits, letters, or hyphens.
-
-			createToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`);
-
-			// ## Build Metadata
-			// Plus sign, followed by one or more period-separated build metadata
-			// identifiers.
+	    const {
+	      MAX_SAFE_COMPONENT_LENGTH,
+	      MAX_SAFE_BUILD_LENGTH,
+	      MAX_LENGTH
+	    } = requireConstants();
+	    const debug = requireDebug();
+	    exports = module.exports = {};
+
+	    // The actual regexps go on exports.re
+	    const re = exports.re = [];
+	    const safeRe = exports.safeRe = [];
+	    const src = exports.src = [];
+	    const safeSrc = exports.safeSrc = [];
+	    const t = exports.t = {};
+	    let R = 0;
+	    const LETTERDASHNUMBER = '[a-zA-Z0-9-]';
+
+	    // Replace some greedy regex tokens to prevent regex dos issues. These regex are
+	    // used internally via the safeRe object since all inputs in this library get
+	    // normalized first to trim and collapse all extra whitespace. The original
+	    // regexes are exported for userland consumption and lower level usage. A
+	    // future breaking change could export the safer regex only with a note that
+	    // all input should have extra whitespace removed.
+	    const safeRegexReplacements = [['\\s', 1], ['\\d', MAX_LENGTH], [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]];
+	    const makeSafeRegex = value => {
+	      for (const [token, max] of safeRegexReplacements) {
+	        value = value.split("".concat(token, "*")).join("".concat(token, "{0,").concat(max, "}")).split("".concat(token, "+")).join("".concat(token, "{1,").concat(max, "}"));
+	      }
+	      return value;
+	    };
+	    const createToken = (name, value, isGlobal) => {
+	      const safe = makeSafeRegex(value);
+	      const index = R++;
+	      debug(name, index, value);
+	      t[name] = index;
+	      src[index] = value;
+	      safeSrc[index] = safe;
+	      re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
+	      safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined);
+	    };
 
-			createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
-		}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
-
-			// ## Full Version String
-			// A main version, followed optionally by a pre-release version and
-			// build metadata.
-
-			// Note that the only major, minor, patch, and pre-release sections of
-			// the version string are capturing groups.  The build metadata is not a
-			// capturing group, because it should not ever be used in version
-			// comparison.
-
-			createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
-		}${src[t.PRERELEASE]}?${
-		  src[t.BUILD]}?`);
-
-			createToken('FULL', `^${src[t.FULLPLAIN]}$`);
-
-			// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
-			// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
-			// common in the npm registry.
-			createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
-		}${src[t.PRERELEASELOOSE]}?${
-		  src[t.BUILD]}?`);
-
-			createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`);
-
-			createToken('GTLT', '((?:<|>)?=?)');
-
-			// Something like "2.*" or "1.2.x".
-			// Note that "x.x" is a valid xRange identifer, meaning "any version"
-			// Only the first item is strictly required.
-			createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
-			createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
-
-			createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
-			                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
-			                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
-			                   `(?:${src[t.PRERELEASE]})?${
-		                     src[t.BUILD]}?` +
-			                   `)?)?`);
-
-			createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
-			                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
-			                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
-			                        `(?:${src[t.PRERELEASELOOSE]})?${
-		                          src[t.BUILD]}?` +
-			                        `)?)?`);
-
-			createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
-			createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
-
-			// Coercion.
-			// Extract anything that could conceivably be a part of a valid semver
-			createToken('COERCEPLAIN', `${'(^|[^\\d])' +
-		              '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
-			              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
-			              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
-			createToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
-			createToken('COERCEFULL', src[t.COERCEPLAIN] +
-			              `(?:${src[t.PRERELEASE]})?` +
-			              `(?:${src[t.BUILD]})?` +
-			              `(?:$|[^\\d])`);
-			createToken('COERCERTL', src[t.COERCE], true);
-			createToken('COERCERTLFULL', src[t.COERCEFULL], true);
-
-			// Tilde ranges.
-			// Meaning is "reasonably at or greater than"
-			createToken('LONETILDE', '(?:~>?)');
-
-			createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
-			exports.tildeTrimReplace = '$1~';
-
-			createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
-			createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
-
-			// Caret ranges.
-			// Meaning is "at least and backwards compatible with"
-			createToken('LONECARET', '(?:\\^)');
-
-			createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true);
-			exports.caretTrimReplace = '$1^';
-
-			createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
-			createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
-
-			// A simple gt/lt/eq thing, or just "" to indicate "any version"
-			createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
-			createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
-
-			// An expression to strip any whitespace between the gtlt and the thing
-			// it modifies, so that `> 1.2.3` ==> `>1.2.3`
-			createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
-		}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
-			exports.comparatorTrimReplace = '$1$2$3';
-
-			// Something like `1.2.3 - 1.2.4`
-			// Note that these all use the loose form, because they'll be
-			// checked against either the strict or loose comparator form
-			// later.
-			createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
-			                   `\\s+-\\s+` +
-			                   `(${src[t.XRANGEPLAIN]})` +
-			                   `\\s*$`);
-
-			createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
-			                        `\\s+-\\s+` +
-			                        `(${src[t.XRANGEPLAINLOOSE]})` +
-			                        `\\s*$`);
-
-			// Star ranges basically just allow anything at all.
-			createToken('STAR', '(<|>)?=?\\s*\\*');
-			// >=0.0.0 is like a star
-			createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$');
-			createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$'); 
-		} (re, re.exports));
-		return re.exports;
+	    // The following Regular Expressions can be used for tokenizing,
+	    // validating, and parsing SemVer version strings.
+
+	    // ## Numeric Identifier
+	    // A single `0`, or a non-zero digit followed by zero or more digits.
+
+	    createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
+	    createToken('NUMERICIDENTIFIERLOOSE', '\\d+');
+
+	    // ## Non-numeric Identifier
+	    // Zero or more digits, followed by a letter or hyphen, and then zero or
+	    // more letters, digits, or hyphens.
+
+	    createToken('NONNUMERICIDENTIFIER', "\\d*[a-zA-Z-]".concat(LETTERDASHNUMBER, "*"));
+
+	    // ## Main Version
+	    // Three dot-separated numeric identifiers.
+
+	    createToken('MAINVERSION', "(".concat(src[t.NUMERICIDENTIFIER], ")\\.") + "(".concat(src[t.NUMERICIDENTIFIER], ")\\.") + "(".concat(src[t.NUMERICIDENTIFIER], ")"));
+	    createToken('MAINVERSIONLOOSE', "(".concat(src[t.NUMERICIDENTIFIERLOOSE], ")\\.") + "(".concat(src[t.NUMERICIDENTIFIERLOOSE], ")\\.") + "(".concat(src[t.NUMERICIDENTIFIERLOOSE], ")"));
+
+	    // ## Pre-release Version Identifier
+	    // A numeric identifier, or a non-numeric identifier.
+	    // Non-numberic identifiers include numberic identifiers but can be longer.
+	    // Therefore non-numberic identifiers must go first.
+
+	    createToken('PRERELEASEIDENTIFIER', "(?:".concat(src[t.NONNUMERICIDENTIFIER], "|").concat(src[t.NUMERICIDENTIFIER], ")"));
+	    createToken('PRERELEASEIDENTIFIERLOOSE', "(?:".concat(src[t.NONNUMERICIDENTIFIER], "|").concat(src[t.NUMERICIDENTIFIERLOOSE], ")"));
+
+	    // ## Pre-release Version
+	    // Hyphen, followed by one or more dot-separated pre-release version
+	    // identifiers.
+
+	    createToken('PRERELEASE', "(?:-(".concat(src[t.PRERELEASEIDENTIFIER], "(?:\\.").concat(src[t.PRERELEASEIDENTIFIER], ")*))"));
+	    createToken('PRERELEASELOOSE', "(?:-?(".concat(src[t.PRERELEASEIDENTIFIERLOOSE], "(?:\\.").concat(src[t.PRERELEASEIDENTIFIERLOOSE], ")*))"));
+
+	    // ## Build Metadata Identifier
+	    // Any combination of digits, letters, or hyphens.
+
+	    createToken('BUILDIDENTIFIER', "".concat(LETTERDASHNUMBER, "+"));
+
+	    // ## Build Metadata
+	    // Plus sign, followed by one or more period-separated build metadata
+	    // identifiers.
+
+	    createToken('BUILD', "(?:\\+(".concat(src[t.BUILDIDENTIFIER], "(?:\\.").concat(src[t.BUILDIDENTIFIER], ")*))"));
+
+	    // ## Full Version String
+	    // A main version, followed optionally by a pre-release version and
+	    // build metadata.
+
+	    // Note that the only major, minor, patch, and pre-release sections of
+	    // the version string are capturing groups.  The build metadata is not a
+	    // capturing group, because it should not ever be used in version
+	    // comparison.
+
+	    createToken('FULLPLAIN', "v?".concat(src[t.MAINVERSION]).concat(src[t.PRERELEASE], "?").concat(src[t.BUILD], "?"));
+	    createToken('FULL', "^".concat(src[t.FULLPLAIN], "$"));
+
+	    // like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+	    // also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+	    // common in the npm registry.
+	    createToken('LOOSEPLAIN', "[v=\\s]*".concat(src[t.MAINVERSIONLOOSE]).concat(src[t.PRERELEASELOOSE], "?").concat(src[t.BUILD], "?"));
+	    createToken('LOOSE', "^".concat(src[t.LOOSEPLAIN], "$"));
+	    createToken('GTLT', '((?:<|>)?=?)');
+
+	    // Something like "2.*" or "1.2.x".
+	    // Note that "x.x" is a valid xRange identifer, meaning "any version"
+	    // Only the first item is strictly required.
+	    createToken('XRANGEIDENTIFIERLOOSE', "".concat(src[t.NUMERICIDENTIFIERLOOSE], "|x|X|\\*"));
+	    createToken('XRANGEIDENTIFIER', "".concat(src[t.NUMERICIDENTIFIER], "|x|X|\\*"));
+	    createToken('XRANGEPLAIN', "[v=\\s]*(".concat(src[t.XRANGEIDENTIFIER], ")") + "(?:\\.(".concat(src[t.XRANGEIDENTIFIER], ")") + "(?:\\.(".concat(src[t.XRANGEIDENTIFIER], ")") + "(?:".concat(src[t.PRERELEASE], ")?").concat(src[t.BUILD], "?") + ")?)?");
+	    createToken('XRANGEPLAINLOOSE', "[v=\\s]*(".concat(src[t.XRANGEIDENTIFIERLOOSE], ")") + "(?:\\.(".concat(src[t.XRANGEIDENTIFIERLOOSE], ")") + "(?:\\.(".concat(src[t.XRANGEIDENTIFIERLOOSE], ")") + "(?:".concat(src[t.PRERELEASELOOSE], ")?").concat(src[t.BUILD], "?") + ")?)?");
+	    createToken('XRANGE', "^".concat(src[t.GTLT], "\\s*").concat(src[t.XRANGEPLAIN], "$"));
+	    createToken('XRANGELOOSE', "^".concat(src[t.GTLT], "\\s*").concat(src[t.XRANGEPLAINLOOSE], "$"));
+
+	    // Coercion.
+	    // Extract anything that could conceivably be a part of a valid semver
+	    createToken('COERCEPLAIN', "".concat('(^|[^\\d])' + '(\\d{1,').concat(MAX_SAFE_COMPONENT_LENGTH, "})") + "(?:\\.(\\d{1,".concat(MAX_SAFE_COMPONENT_LENGTH, "}))?") + "(?:\\.(\\d{1,".concat(MAX_SAFE_COMPONENT_LENGTH, "}))?"));
+	    createToken('COERCE', "".concat(src[t.COERCEPLAIN], "(?:$|[^\\d])"));
+	    createToken('COERCEFULL', src[t.COERCEPLAIN] + "(?:".concat(src[t.PRERELEASE], ")?") + "(?:".concat(src[t.BUILD], ")?") + "(?:$|[^\\d])");
+	    createToken('COERCERTL', src[t.COERCE], true);
+	    createToken('COERCERTLFULL', src[t.COERCEFULL], true);
+
+	    // Tilde ranges.
+	    // Meaning is "reasonably at or greater than"
+	    createToken('LONETILDE', '(?:~>?)');
+	    createToken('TILDETRIM', "(\\s*)".concat(src[t.LONETILDE], "\\s+"), true);
+	    exports.tildeTrimReplace = '$1~';
+	    createToken('TILDE', "^".concat(src[t.LONETILDE]).concat(src[t.XRANGEPLAIN], "$"));
+	    createToken('TILDELOOSE', "^".concat(src[t.LONETILDE]).concat(src[t.XRANGEPLAINLOOSE], "$"));
+
+	    // Caret ranges.
+	    // Meaning is "at least and backwards compatible with"
+	    createToken('LONECARET', '(?:\\^)');
+	    createToken('CARETTRIM', "(\\s*)".concat(src[t.LONECARET], "\\s+"), true);
+	    exports.caretTrimReplace = '$1^';
+	    createToken('CARET', "^".concat(src[t.LONECARET]).concat(src[t.XRANGEPLAIN], "$"));
+	    createToken('CARETLOOSE', "^".concat(src[t.LONECARET]).concat(src[t.XRANGEPLAINLOOSE], "$"));
+
+	    // A simple gt/lt/eq thing, or just "" to indicate "any version"
+	    createToken('COMPARATORLOOSE', "^".concat(src[t.GTLT], "\\s*(").concat(src[t.LOOSEPLAIN], ")$|^$"));
+	    createToken('COMPARATOR', "^".concat(src[t.GTLT], "\\s*(").concat(src[t.FULLPLAIN], ")$|^$"));
+
+	    // An expression to strip any whitespace between the gtlt and the thing
+	    // it modifies, so that `> 1.2.3` ==> `>1.2.3`
+	    createToken('COMPARATORTRIM', "(\\s*)".concat(src[t.GTLT], "\\s*(").concat(src[t.LOOSEPLAIN], "|").concat(src[t.XRANGEPLAIN], ")"), true);
+	    exports.comparatorTrimReplace = '$1$2$3';
+
+	    // Something like `1.2.3 - 1.2.4`
+	    // Note that these all use the loose form, because they'll be
+	    // checked against either the strict or loose comparator form
+	    // later.
+	    createToken('HYPHENRANGE', "^\\s*(".concat(src[t.XRANGEPLAIN], ")") + "\\s+-\\s+" + "(".concat(src[t.XRANGEPLAIN], ")") + "\\s*$");
+	    createToken('HYPHENRANGELOOSE', "^\\s*(".concat(src[t.XRANGEPLAINLOOSE], ")") + "\\s+-\\s+" + "(".concat(src[t.XRANGEPLAINLOOSE], ")") + "\\s*$");
+
+	    // Star ranges basically just allow anything at all.
+	    createToken('STAR', '(<|>)?=?\\s*\\*');
+	    // >=0.0.0 is like a star
+	    createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$');
+	    createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$');
+	  })(re, re.exports);
+	  return re.exports;
 	}
 
 	var identifiers;
 	var hasRequiredIdentifiers;
-
-	function requireIdentifiers () {
-		if (hasRequiredIdentifiers) return identifiers;
-		hasRequiredIdentifiers = 1;
-
-		const numeric = /^[0-9]+$/;
-		const compareIdentifiers = (a, b) => {
-		  const anum = numeric.test(a);
-		  const bnum = numeric.test(b);
-
-		  if (anum && bnum) {
-		    a = +a;
-		    b = +b;
-		  }
-
-		  return a === b ? 0
-		    : (anum && !bnum) ? -1
-		    : (bnum && !anum) ? 1
-		    : a < b ? -1
-		    : 1
-		};
-
-		const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
-
-		identifiers = {
-		  compareIdentifiers,
-		  rcompareIdentifiers,
-		};
-		return identifiers;
+	function requireIdentifiers() {
+	  if (hasRequiredIdentifiers) return identifiers;
+	  hasRequiredIdentifiers = 1;
+	  const numeric = /^[0-9]+$/;
+	  const compareIdentifiers = (a, b) => {
+	    const anum = numeric.test(a);
+	    const bnum = numeric.test(b);
+	    if (anum && bnum) {
+	      a = +a;
+	      b = +b;
+	    }
+	    return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+	  };
+	  const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+	  identifiers = {
+	    compareIdentifiers,
+	    rcompareIdentifiers
+	  };
+	  return identifiers;
 	}
 
 	var semver;
 	var hasRequiredSemver;
+	function requireSemver() {
+	  if (hasRequiredSemver) return semver;
+	  hasRequiredSemver = 1;
+	  const debug = requireDebug();
+	  const {
+	    MAX_LENGTH,
+	    MAX_SAFE_INTEGER
+	  } = requireConstants();
+	  const {
+	    safeRe: re,
+	    t
+	  } = requireRe();
+	  const parseOptions = requireParseOptions();
+	  const {
+	    compareIdentifiers
+	  } = requireIdentifiers();
+	  class SemVer {
+	    constructor(version, options) {
+	      options = parseOptions(options);
+	      if (version instanceof SemVer) {
+	        if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+	          return version;
+	        } else {
+	          version = version.version;
+	        }
+	      } else if (typeof version !== 'string') {
+	        throw new TypeError("Invalid version. Must be a string. Got type \"".concat(typeof version, "\"."));
+	      }
+	      if (version.length > MAX_LENGTH) {
+	        throw new TypeError("version is longer than ".concat(MAX_LENGTH, " characters"));
+	      }
+	      debug('SemVer', version, options);
+	      this.options = options;
+	      this.loose = !!options.loose;
+	      // this isn't actually relevant for versions, but keep it so that we
+	      // don't run into trouble passing this.options around.
+	      this.includePrerelease = !!options.includePrerelease;
+	      const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+	      if (!m) {
+	        throw new TypeError("Invalid Version: ".concat(version));
+	      }
+	      this.raw = version;
 
-	function requireSemver () {
-		if (hasRequiredSemver) return semver;
-		hasRequiredSemver = 1;
-
-		const debug = requireDebug();
-		const { MAX_LENGTH, MAX_SAFE_INTEGER } = requireConstants();
-		const { safeRe: re, t } = requireRe();
-
-		const parseOptions = requireParseOptions();
-		const { compareIdentifiers } = requireIdentifiers();
-		class SemVer {
-		  constructor (version, options) {
-		    options = parseOptions(options);
-
-		    if (version instanceof SemVer) {
-		      if (version.loose === !!options.loose &&
-		        version.includePrerelease === !!options.includePrerelease) {
-		        return version
-		      } else {
-		        version = version.version;
-		      }
-		    } else if (typeof version !== 'string') {
-		      throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`)
-		    }
-
-		    if (version.length > MAX_LENGTH) {
-		      throw new TypeError(
-		        `version is longer than ${MAX_LENGTH} characters`
-		      )
-		    }
-
-		    debug('SemVer', version, options);
-		    this.options = options;
-		    this.loose = !!options.loose;
-		    // this isn't actually relevant for versions, but keep it so that we
-		    // don't run into trouble passing this.options around.
-		    this.includePrerelease = !!options.includePrerelease;
-
-		    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
-
-		    if (!m) {
-		      throw new TypeError(`Invalid Version: ${version}`)
-		    }
-
-		    this.raw = version;
-
-		    // these are actually numbers
-		    this.major = +m[1];
-		    this.minor = +m[2];
-		    this.patch = +m[3];
-
-		    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
-		      throw new TypeError('Invalid major version')
-		    }
-
-		    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
-		      throw new TypeError('Invalid minor version')
-		    }
-
-		    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
-		      throw new TypeError('Invalid patch version')
-		    }
-
-		    // numberify any prerelease numeric ids
-		    if (!m[4]) {
-		      this.prerelease = [];
-		    } else {
-		      this.prerelease = m[4].split('.').map((id) => {
-		        if (/^[0-9]+$/.test(id)) {
-		          const num = +id;
-		          if (num >= 0 && num < MAX_SAFE_INTEGER) {
-		            return num
-		          }
-		        }
-		        return id
-		      });
-		    }
-
-		    this.build = m[5] ? m[5].split('.') : [];
-		    this.format();
-		  }
-
-		  format () {
-		    this.version = `${this.major}.${this.minor}.${this.patch}`;
-		    if (this.prerelease.length) {
-		      this.version += `-${this.prerelease.join('.')}`;
-		    }
-		    return this.version
-		  }
-
-		  toString () {
-		    return this.version
-		  }
-
-		  compare (other) {
-		    debug('SemVer.compare', this.version, this.options, other);
-		    if (!(other instanceof SemVer)) {
-		      if (typeof other === 'string' && other === this.version) {
-		        return 0
-		      }
-		      other = new SemVer(other, this.options);
-		    }
-
-		    if (other.version === this.version) {
-		      return 0
-		    }
-
-		    return this.compareMain(other) || this.comparePre(other)
-		  }
-
-		  compareMain (other) {
-		    if (!(other instanceof SemVer)) {
-		      other = new SemVer(other, this.options);
-		    }
-
-		    return (
-		      compareIdentifiers(this.major, other.major) ||
-		      compareIdentifiers(this.minor, other.minor) ||
-		      compareIdentifiers(this.patch, other.patch)
-		    )
-		  }
-
-		  comparePre (other) {
-		    if (!(other instanceof SemVer)) {
-		      other = new SemVer(other, this.options);
-		    }
-
-		    // NOT having a prerelease is > having one
-		    if (this.prerelease.length && !other.prerelease.length) {
-		      return -1
-		    } else if (!this.prerelease.length && other.prerelease.length) {
-		      return 1
-		    } else if (!this.prerelease.length && !other.prerelease.length) {
-		      return 0
-		    }
-
-		    let i = 0;
-		    do {
-		      const a = this.prerelease[i];
-		      const b = other.prerelease[i];
-		      debug('prerelease compare', i, a, b);
-		      if (a === undefined && b === undefined) {
-		        return 0
-		      } else if (b === undefined) {
-		        return 1
-		      } else if (a === undefined) {
-		        return -1
-		      } else if (a === b) {
-		        continue
-		      } else {
-		        return compareIdentifiers(a, b)
-		      }
-		    } while (++i)
-		  }
-
-		  compareBuild (other) {
-		    if (!(other instanceof SemVer)) {
-		      other = new SemVer(other, this.options);
-		    }
-
-		    let i = 0;
-		    do {
-		      const a = this.build[i];
-		      const b = other.build[i];
-		      debug('build compare', i, a, b);
-		      if (a === undefined && b === undefined) {
-		        return 0
-		      } else if (b === undefined) {
-		        return 1
-		      } else if (a === undefined) {
-		        return -1
-		      } else if (a === b) {
-		        continue
-		      } else {
-		        return compareIdentifiers(a, b)
-		      }
-		    } while (++i)
-		  }
+	      // these are actually numbers
+	      this.major = +m[1];
+	      this.minor = +m[2];
+	      this.patch = +m[3];
+	      if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+	        throw new TypeError('Invalid major version');
+	      }
+	      if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+	        throw new TypeError('Invalid minor version');
+	      }
+	      if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+	        throw new TypeError('Invalid patch version');
+	      }
 
-		  // preminor will bump the version up to the next minor release, and immediately
-		  // down to pre-release. premajor and prepatch work the same way.
-		  inc (release, identifier, identifierBase) {
-		    if (release.startsWith('pre')) {
-		      if (!identifier && identifierBase === false) {
-		        throw new Error('invalid increment argument: identifier is empty')
-		      }
-		      // Avoid an invalid semver results
-		      if (identifier) {
-		        const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
-		        if (!match || match[1] !== identifier) {
-		          throw new Error(`invalid identifier: ${identifier}`)
-		        }
-		      }
-		    }
+	      // numberify any prerelease numeric ids
+	      if (!m[4]) {
+	        this.prerelease = [];
+	      } else {
+	        this.prerelease = m[4].split('.').map(id => {
+	          if (/^[0-9]+$/.test(id)) {
+	            const num = +id;
+	            if (num >= 0 && num < MAX_SAFE_INTEGER) {
+	              return num;
+	            }
+	          }
+	          return id;
+	        });
+	      }
+	      this.build = m[5] ? m[5].split('.') : [];
+	      this.format();
+	    }
+	    format() {
+	      this.version = "".concat(this.major, ".").concat(this.minor, ".").concat(this.patch);
+	      if (this.prerelease.length) {
+	        this.version += "-".concat(this.prerelease.join('.'));
+	      }
+	      return this.version;
+	    }
+	    toString() {
+	      return this.version;
+	    }
+	    compare(other) {
+	      debug('SemVer.compare', this.version, this.options, other);
+	      if (!(other instanceof SemVer)) {
+	        if (typeof other === 'string' && other === this.version) {
+	          return 0;
+	        }
+	        other = new SemVer(other, this.options);
+	      }
+	      if (other.version === this.version) {
+	        return 0;
+	      }
+	      return this.compareMain(other) || this.comparePre(other);
+	    }
+	    compareMain(other) {
+	      if (!(other instanceof SemVer)) {
+	        other = new SemVer(other, this.options);
+	      }
+	      return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+	    }
+	    comparePre(other) {
+	      if (!(other instanceof SemVer)) {
+	        other = new SemVer(other, this.options);
+	      }
 
-		    switch (release) {
-		      case 'premajor':
-		        this.prerelease.length = 0;
-		        this.patch = 0;
-		        this.minor = 0;
-		        this.major++;
-		        this.inc('pre', identifier, identifierBase);
-		        break
-		      case 'preminor':
-		        this.prerelease.length = 0;
-		        this.patch = 0;
-		        this.minor++;
-		        this.inc('pre', identifier, identifierBase);
-		        break
-		      case 'prepatch':
-		        // If this is already a prerelease, it will bump to the next version
-		        // drop any prereleases that might already exist, since they are not
-		        // relevant at this point.
-		        this.prerelease.length = 0;
-		        this.inc('patch', identifier, identifierBase);
-		        this.inc('pre', identifier, identifierBase);
-		        break
-		      // If the input is a non-prerelease version, this acts the same as
-		      // prepatch.
-		      case 'prerelease':
-		        if (this.prerelease.length === 0) {
-		          this.inc('patch', identifier, identifierBase);
-		        }
-		        this.inc('pre', identifier, identifierBase);
-		        break
-		      case 'release':
-		        if (this.prerelease.length === 0) {
-		          throw new Error(`version ${this.raw} is not a prerelease`)
-		        }
-		        this.prerelease.length = 0;
-		        break
-
-		      case 'major':
-		        // If this is a pre-major version, bump up to the same major version.
-		        // Otherwise increment major.
-		        // 1.0.0-5 bumps to 1.0.0
-		        // 1.1.0 bumps to 2.0.0
-		        if (
-		          this.minor !== 0 ||
-		          this.patch !== 0 ||
-		          this.prerelease.length === 0
-		        ) {
-		          this.major++;
-		        }
-		        this.minor = 0;
-		        this.patch = 0;
-		        this.prerelease = [];
-		        break
-		      case 'minor':
-		        // If this is a pre-minor version, bump up to the same minor version.
-		        // Otherwise increment minor.
-		        // 1.2.0-5 bumps to 1.2.0
-		        // 1.2.1 bumps to 1.3.0
-		        if (this.patch !== 0 || this.prerelease.length === 0) {
-		          this.minor++;
-		        }
-		        this.patch = 0;
-		        this.prerelease = [];
-		        break
-		      case 'patch':
-		        // If this is not a pre-release version, it will increment the patch.
-		        // If it is a pre-release it will bump up to the same patch version.
-		        // 1.2.0-5 patches to 1.2.0
-		        // 1.2.0 patches to 1.2.1
-		        if (this.prerelease.length === 0) {
-		          this.patch++;
-		        }
-		        this.prerelease = [];
-		        break
-		      // This probably shouldn't be used publicly.
-		      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
-		      case 'pre': {
-		        const base = Number(identifierBase) ? 1 : 0;
-
-		        if (this.prerelease.length === 0) {
-		          this.prerelease = [base];
-		        } else {
-		          let i = this.prerelease.length;
-		          while (--i >= 0) {
-		            if (typeof this.prerelease[i] === 'number') {
-		              this.prerelease[i]++;
-		              i = -2;
-		            }
-		          }
-		          if (i === -1) {
-		            // didn't increment anything
-		            if (identifier === this.prerelease.join('.') && identifierBase === false) {
-		              throw new Error('invalid increment argument: identifier already exists')
-		            }
-		            this.prerelease.push(base);
-		          }
-		        }
-		        if (identifier) {
-		          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
-		          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
-		          let prerelease = [identifier, base];
-		          if (identifierBase === false) {
-		            prerelease = [identifier];
-		          }
-		          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
-		            if (isNaN(this.prerelease[1])) {
-		              this.prerelease = prerelease;
-		            }
-		          } else {
-		            this.prerelease = prerelease;
-		          }
-		        }
-		        break
-		      }
-		      default:
-		        throw new Error(`invalid increment argument: ${release}`)
-		    }
-		    this.raw = this.format();
-		    if (this.build.length) {
-		      this.raw += `+${this.build.join('.')}`;
-		    }
-		    return this
-		  }
-		}
+	      // NOT having a prerelease is > having one
+	      if (this.prerelease.length && !other.prerelease.length) {
+	        return -1;
+	      } else if (!this.prerelease.length && other.prerelease.length) {
+	        return 1;
+	      } else if (!this.prerelease.length && !other.prerelease.length) {
+	        return 0;
+	      }
+	      let i = 0;
+	      do {
+	        const a = this.prerelease[i];
+	        const b = other.prerelease[i];
+	        debug('prerelease compare', i, a, b);
+	        if (a === undefined && b === undefined) {
+	          return 0;
+	        } else if (b === undefined) {
+	          return 1;
+	        } else if (a === undefined) {
+	          return -1;
+	        } else if (a === b) {
+	          continue;
+	        } else {
+	          return compareIdentifiers(a, b);
+	        }
+	      } while (++i);
+	    }
+	    compareBuild(other) {
+	      if (!(other instanceof SemVer)) {
+	        other = new SemVer(other, this.options);
+	      }
+	      let i = 0;
+	      do {
+	        const a = this.build[i];
+	        const b = other.build[i];
+	        debug('build compare', i, a, b);
+	        if (a === undefined && b === undefined) {
+	          return 0;
+	        } else if (b === undefined) {
+	          return 1;
+	        } else if (a === undefined) {
+	          return -1;
+	        } else if (a === b) {
+	          continue;
+	        } else {
+	          return compareIdentifiers(a, b);
+	        }
+	      } while (++i);
+	    }
 
-		semver = SemVer;
-		return semver;
+	    // preminor will bump the version up to the next minor release, and immediately
+	    // down to pre-release. premajor and prepatch work the same way.
+	    inc(release, identifier, identifierBase) {
+	      if (release.startsWith('pre')) {
+	        if (!identifier && identifierBase === false) {
+	          throw new Error('invalid increment argument: identifier is empty');
+	        }
+	        // Avoid an invalid semver results
+	        if (identifier) {
+	          const match = "-".concat(identifier).match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+	          if (!match || match[1] !== identifier) {
+	            throw new Error("invalid identifier: ".concat(identifier));
+	          }
+	        }
+	      }
+	      switch (release) {
+	        case 'premajor':
+	          this.prerelease.length = 0;
+	          this.patch = 0;
+	          this.minor = 0;
+	          this.major++;
+	          this.inc('pre', identifier, identifierBase);
+	          break;
+	        case 'preminor':
+	          this.prerelease.length = 0;
+	          this.patch = 0;
+	          this.minor++;
+	          this.inc('pre', identifier, identifierBase);
+	          break;
+	        case 'prepatch':
+	          // If this is already a prerelease, it will bump to the next version
+	          // drop any prereleases that might already exist, since they are not
+	          // relevant at this point.
+	          this.prerelease.length = 0;
+	          this.inc('patch', identifier, identifierBase);
+	          this.inc('pre', identifier, identifierBase);
+	          break;
+	        // If the input is a non-prerelease version, this acts the same as
+	        // prepatch.
+	        case 'prerelease':
+	          if (this.prerelease.length === 0) {
+	            this.inc('patch', identifier, identifierBase);
+	          }
+	          this.inc('pre', identifier, identifierBase);
+	          break;
+	        case 'release':
+	          if (this.prerelease.length === 0) {
+	            throw new Error("version ".concat(this.raw, " is not a prerelease"));
+	          }
+	          this.prerelease.length = 0;
+	          break;
+	        case 'major':
+	          // If this is a pre-major version, bump up to the same major version.
+	          // Otherwise increment major.
+	          // 1.0.0-5 bumps to 1.0.0
+	          // 1.1.0 bumps to 2.0.0
+	          if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+	            this.major++;
+	          }
+	          this.minor = 0;
+	          this.patch = 0;
+	          this.prerelease = [];
+	          break;
+	        case 'minor':
+	          // If this is a pre-minor version, bump up to the same minor version.
+	          // Otherwise increment minor.
+	          // 1.2.0-5 bumps to 1.2.0
+	          // 1.2.1 bumps to 1.3.0
+	          if (this.patch !== 0 || this.prerelease.length === 0) {
+	            this.minor++;
+	          }
+	          this.patch = 0;
+	          this.prerelease = [];
+	          break;
+	        case 'patch':
+	          // If this is not a pre-release version, it will increment the patch.
+	          // If it is a pre-release it will bump up to the same patch version.
+	          // 1.2.0-5 patches to 1.2.0
+	          // 1.2.0 patches to 1.2.1
+	          if (this.prerelease.length === 0) {
+	            this.patch++;
+	          }
+	          this.prerelease = [];
+	          break;
+	        // This probably shouldn't be used publicly.
+	        // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+	        case 'pre':
+	          {
+	            const base = Number(identifierBase) ? 1 : 0;
+	            if (this.prerelease.length === 0) {
+	              this.prerelease = [base];
+	            } else {
+	              let i = this.prerelease.length;
+	              while (--i >= 0) {
+	                if (typeof this.prerelease[i] === 'number') {
+	                  this.prerelease[i]++;
+	                  i = -2;
+	                }
+	              }
+	              if (i === -1) {
+	                // didn't increment anything
+	                if (identifier === this.prerelease.join('.') && identifierBase === false) {
+	                  throw new Error('invalid increment argument: identifier already exists');
+	                }
+	                this.prerelease.push(base);
+	              }
+	            }
+	            if (identifier) {
+	              // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+	              // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+	              let prerelease = [identifier, base];
+	              if (identifierBase === false) {
+	                prerelease = [identifier];
+	              }
+	              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+	                if (isNaN(this.prerelease[1])) {
+	                  this.prerelease = prerelease;
+	                }
+	              } else {
+	                this.prerelease = prerelease;
+	              }
+	            }
+	            break;
+	          }
+	        default:
+	          throw new Error("invalid increment argument: ".concat(release));
+	      }
+	      this.raw = this.format();
+	      if (this.build.length) {
+	        this.raw += "+".concat(this.build.join('.'));
+	      }
+	      return this;
+	    }
+	  }
+	  semver = SemVer;
+	  return semver;
 	}
 
 	var compare_1;
 	var hasRequiredCompare;
-
-	function requireCompare () {
-		if (hasRequiredCompare) return compare_1;
-		hasRequiredCompare = 1;
-
-		const SemVer = requireSemver();
-		const compare = (a, b, loose) =>
-		  new SemVer(a, loose).compare(new SemVer(b, loose));
-
-		compare_1 = compare;
-		return compare_1;
+	function requireCompare() {
+	  if (hasRequiredCompare) return compare_1;
+	  hasRequiredCompare = 1;
+	  const SemVer = requireSemver();
+	  const compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+	  compare_1 = compare;
+	  return compare_1;
 	}
 
 	var eq_1;
 	var hasRequiredEq;
-
-	function requireEq () {
-		if (hasRequiredEq) return eq_1;
-		hasRequiredEq = 1;
-
-		const compare = requireCompare();
-		const eq = (a, b, loose) => compare(a, b, loose) === 0;
-		eq_1 = eq;
-		return eq_1;
+	function requireEq() {
+	  if (hasRequiredEq) return eq_1;
+	  hasRequiredEq = 1;
+	  const compare = requireCompare();
+	  const eq = (a, b, loose) => compare(a, b, loose) === 0;
+	  eq_1 = eq;
+	  return eq_1;
 	}
 
 	var neq_1;
 	var hasRequiredNeq;
-
-	function requireNeq () {
-		if (hasRequiredNeq) return neq_1;
-		hasRequiredNeq = 1;
-
-		const compare = requireCompare();
-		const neq = (a, b, loose) => compare(a, b, loose) !== 0;
-		neq_1 = neq;
-		return neq_1;
+	function requireNeq() {
+	  if (hasRequiredNeq) return neq_1;
+	  hasRequiredNeq = 1;
+	  const compare = requireCompare();
+	  const neq = (a, b, loose) => compare(a, b, loose) !== 0;
+	  neq_1 = neq;
+	  return neq_1;
 	}
 
 	var gt_1;
 	var hasRequiredGt;
-
-	function requireGt () {
-		if (hasRequiredGt) return gt_1;
-		hasRequiredGt = 1;
-
-		const compare = requireCompare();
-		const gt = (a, b, loose) => compare(a, b, loose) > 0;
-		gt_1 = gt;
-		return gt_1;
+	function requireGt() {
+	  if (hasRequiredGt) return gt_1;
+	  hasRequiredGt = 1;
+	  const compare = requireCompare();
+	  const gt = (a, b, loose) => compare(a, b, loose) > 0;
+	  gt_1 = gt;
+	  return gt_1;
 	}
 
 	var gte_1;
 	var hasRequiredGte;
-
-	function requireGte () {
-		if (hasRequiredGte) return gte_1;
-		hasRequiredGte = 1;
-
-		const compare = requireCompare();
-		const gte = (a, b, loose) => compare(a, b, loose) >= 0;
-		gte_1 = gte;
-		return gte_1;
+	function requireGte() {
+	  if (hasRequiredGte) return gte_1;
+	  hasRequiredGte = 1;
+	  const compare = requireCompare();
+	  const gte = (a, b, loose) => compare(a, b, loose) >= 0;
+	  gte_1 = gte;
+	  return gte_1;
 	}
 
 	var lt_1;
 	var hasRequiredLt;
-
-	function requireLt () {
-		if (hasRequiredLt) return lt_1;
-		hasRequiredLt = 1;
-
-		const compare = requireCompare();
-		const lt = (a, b, loose) => compare(a, b, loose) < 0;
-		lt_1 = lt;
-		return lt_1;
+	function requireLt() {
+	  if (hasRequiredLt) return lt_1;
+	  hasRequiredLt = 1;
+	  const compare = requireCompare();
+	  const lt = (a, b, loose) => compare(a, b, loose) < 0;
+	  lt_1 = lt;
+	  return lt_1;
 	}
 
 	var lte_1;
 	var hasRequiredLte;
-
-	function requireLte () {
-		if (hasRequiredLte) return lte_1;
-		hasRequiredLte = 1;
-
-		const compare = requireCompare();
-		const lte = (a, b, loose) => compare(a, b, loose) <= 0;
-		lte_1 = lte;
-		return lte_1;
+	function requireLte() {
+	  if (hasRequiredLte) return lte_1;
+	  hasRequiredLte = 1;
+	  const compare = requireCompare();
+	  const lte = (a, b, loose) => compare(a, b, loose) <= 0;
+	  lte_1 = lte;
+	  return lte_1;
 	}
 
 	var cmp_1;
 	var hasRequiredCmp;
-
-	function requireCmp () {
-		if (hasRequiredCmp) return cmp_1;
-		hasRequiredCmp = 1;
-
-		const eq = requireEq();
-		const neq = requireNeq();
-		const gt = requireGt();
-		const gte = requireGte();
-		const lt = requireLt();
-		const lte = requireLte();
-
-		const cmp = (a, op, b, loose) => {
-		  switch (op) {
-		    case '===':
-		      if (typeof a === 'object') {
-		        a = a.version;
-		      }
-		      if (typeof b === 'object') {
-		        b = b.version;
-		      }
-		      return a === b
-
-		    case '!==':
-		      if (typeof a === 'object') {
-		        a = a.version;
-		      }
-		      if (typeof b === 'object') {
-		        b = b.version;
-		      }
-		      return a !== b
-
-		    case '':
-		    case '=':
-		    case '==':
-		      return eq(a, b, loose)
-
-		    case '!=':
-		      return neq(a, b, loose)
-
-		    case '>':
-		      return gt(a, b, loose)
-
-		    case '>=':
-		      return gte(a, b, loose)
-
-		    case '<':
-		      return lt(a, b, loose)
-
-		    case '<=':
-		      return lte(a, b, loose)
-
-		    default:
-		      throw new TypeError(`Invalid operator: ${op}`)
-		  }
-		};
-		cmp_1 = cmp;
-		return cmp_1;
+	function requireCmp() {
+	  if (hasRequiredCmp) return cmp_1;
+	  hasRequiredCmp = 1;
+	  const eq = requireEq();
+	  const neq = requireNeq();
+	  const gt = requireGt();
+	  const gte = requireGte();
+	  const lt = requireLt();
+	  const lte = requireLte();
+	  const cmp = (a, op, b, loose) => {
+	    switch (op) {
+	      case '===':
+	        if (typeof a === 'object') {
+	          a = a.version;
+	        }
+	        if (typeof b === 'object') {
+	          b = b.version;
+	        }
+	        return a === b;
+	      case '!==':
+	        if (typeof a === 'object') {
+	          a = a.version;
+	        }
+	        if (typeof b === 'object') {
+	          b = b.version;
+	        }
+	        return a !== b;
+	      case '':
+	      case '=':
+	      case '==':
+	        return eq(a, b, loose);
+	      case '!=':
+	        return neq(a, b, loose);
+	      case '>':
+	        return gt(a, b, loose);
+	      case '>=':
+	        return gte(a, b, loose);
+	      case '<':
+	        return lt(a, b, loose);
+	      case '<=':
+	        return lte(a, b, loose);
+	      default:
+	        throw new TypeError("Invalid operator: ".concat(op));
+	    }
+	  };
+	  cmp_1 = cmp;
+	  return cmp_1;
 	}
 
 	var comparator;
 	var hasRequiredComparator;
+	function requireComparator() {
+	  if (hasRequiredComparator) return comparator;
+	  hasRequiredComparator = 1;
+	  const ANY = Symbol('SemVer ANY');
+	  // hoisted class for cyclic dependency
+	  class Comparator {
+	    static get ANY() {
+	      return ANY;
+	    }
+	    constructor(comp, options) {
+	      options = parseOptions(options);
+	      if (comp instanceof Comparator) {
+	        if (comp.loose === !!options.loose) {
+	          return comp;
+	        } else {
+	          comp = comp.value;
+	        }
+	      }
+	      comp = comp.trim().split(/\s+/).join(' ');
+	      debug('comparator', comp, options);
+	      this.options = options;
+	      this.loose = !!options.loose;
+	      this.parse(comp);
+	      if (this.semver === ANY) {
+	        this.value = '';
+	      } else {
+	        this.value = this.operator + this.semver.version;
+	      }
+	      debug('comp', this);
+	    }
+	    parse(comp) {
+	      const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+	      const m = comp.match(r);
+	      if (!m) {
+	        throw new TypeError("Invalid comparator: ".concat(comp));
+	      }
+	      this.operator = m[1] !== undefined ? m[1] : '';
+	      if (this.operator === '=') {
+	        this.operator = '';
+	      }
 
-	function requireComparator () {
-		if (hasRequiredComparator) return comparator;
-		hasRequiredComparator = 1;
-
-		const ANY = Symbol('SemVer ANY');
-		// hoisted class for cyclic dependency
-		class Comparator {
-		  static get ANY () {
-		    return ANY
-		  }
-
-		  constructor (comp, options) {
-		    options = parseOptions(options);
-
-		    if (comp instanceof Comparator) {
-		      if (comp.loose === !!options.loose) {
-		        return comp
-		      } else {
-		        comp = comp.value;
-		      }
-		    }
-
-		    comp = comp.trim().split(/\s+/).join(' ');
-		    debug('comparator', comp, options);
-		    this.options = options;
-		    this.loose = !!options.loose;
-		    this.parse(comp);
-
-		    if (this.semver === ANY) {
-		      this.value = '';
-		    } else {
-		      this.value = this.operator + this.semver.version;
-		    }
-
-		    debug('comp', this);
-		  }
-
-		  parse (comp) {
-		    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
-		    const m = comp.match(r);
-
-		    if (!m) {
-		      throw new TypeError(`Invalid comparator: ${comp}`)
-		    }
-
-		    this.operator = m[1] !== undefined ? m[1] : '';
-		    if (this.operator === '=') {
-		      this.operator = '';
-		    }
-
-		    // if it literally is just '>' or '' then allow anything.
-		    if (!m[2]) {
-		      this.semver = ANY;
-		    } else {
-		      this.semver = new SemVer(m[2], this.options.loose);
-		    }
-		  }
-
-		  toString () {
-		    return this.value
-		  }
-
-		  test (version) {
-		    debug('Comparator.test', version, this.options.loose);
-
-		    if (this.semver === ANY || version === ANY) {
-		      return true
-		    }
-
-		    if (typeof version === 'string') {
-		      try {
-		        version = new SemVer(version, this.options);
-		      } catch (er) {
-		        return false
-		      }
-		    }
-
-		    return cmp(version, this.operator, this.semver, this.options)
-		  }
-
-		  intersects (comp, options) {
-		    if (!(comp instanceof Comparator)) {
-		      throw new TypeError('a Comparator is required')
-		    }
-
-		    if (this.operator === '') {
-		      if (this.value === '') {
-		        return true
-		      }
-		      return new Range(comp.value, options).test(this.value)
-		    } else if (comp.operator === '') {
-		      if (comp.value === '') {
-		        return true
-		      }
-		      return new Range(this.value, options).test(comp.semver)
-		    }
-
-		    options = parseOptions(options);
-
-		    // Special cases where nothing can possibly be lower
-		    if (options.includePrerelease &&
-		      (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {
-		      return false
-		    }
-		    if (!options.includePrerelease &&
-		      (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {
-		      return false
-		    }
-
-		    // Same direction increasing (> or >=)
-		    if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {
-		      return true
-		    }
-		    // Same direction decreasing (< or <=)
-		    if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {
-		      return true
-		    }
-		    // same SemVer and both sides are inclusive (<= or >=)
-		    if (
-		      (this.semver.version === comp.semver.version) &&
-		      this.operator.includes('=') && comp.operator.includes('=')) {
-		      return true
-		    }
-		    // opposite directions less than
-		    if (cmp(this.semver, '<', comp.semver, options) &&
-		      this.operator.startsWith('>') && comp.operator.startsWith('<')) {
-		      return true
-		    }
-		    // opposite directions greater than
-		    if (cmp(this.semver, '>', comp.semver, options) &&
-		      this.operator.startsWith('<') && comp.operator.startsWith('>')) {
-		      return true
-		    }
-		    return false
-		  }
-		}
+	      // if it literally is just '>' or '' then allow anything.
+	      if (!m[2]) {
+	        this.semver = ANY;
+	      } else {
+	        this.semver = new SemVer(m[2], this.options.loose);
+	      }
+	    }
+	    toString() {
+	      return this.value;
+	    }
+	    test(version) {
+	      debug('Comparator.test', version, this.options.loose);
+	      if (this.semver === ANY || version === ANY) {
+	        return true;
+	      }
+	      if (typeof version === 'string') {
+	        try {
+	          version = new SemVer(version, this.options);
+	        } catch (er) {
+	          return false;
+	        }
+	      }
+	      return cmp(version, this.operator, this.semver, this.options);
+	    }
+	    intersects(comp, options) {
+	      if (!(comp instanceof Comparator)) {
+	        throw new TypeError('a Comparator is required');
+	      }
+	      if (this.operator === '') {
+	        if (this.value === '') {
+	          return true;
+	        }
+	        return new Range(comp.value, options).test(this.value);
+	      } else if (comp.operator === '') {
+	        if (comp.value === '') {
+	          return true;
+	        }
+	        return new Range(this.value, options).test(comp.semver);
+	      }
+	      options = parseOptions(options);
 
-		comparator = Comparator;
+	      // Special cases where nothing can possibly be lower
+	      if (options.includePrerelease && (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {
+	        return false;
+	      }
+	      if (!options.includePrerelease && (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {
+	        return false;
+	      }
 
-		const parseOptions = requireParseOptions();
-		const { safeRe: re, t } = requireRe();
-		const cmp = requireCmp();
-		const debug = requireDebug();
-		const SemVer = requireSemver();
-		const Range = requireRange();
-		return comparator;
+	      // Same direction increasing (> or >=)
+	      if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {
+	        return true;
+	      }
+	      // Same direction decreasing (< or <=)
+	      if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {
+	        return true;
+	      }
+	      // same SemVer and both sides are inclusive (<= or >=)
+	      if (this.semver.version === comp.semver.version && this.operator.includes('=') && comp.operator.includes('=')) {
+	        return true;
+	      }
+	      // opposite directions less than
+	      if (cmp(this.semver, '<', comp.semver, options) && this.operator.startsWith('>') && comp.operator.startsWith('<')) {
+	        return true;
+	      }
+	      // opposite directions greater than
+	      if (cmp(this.semver, '>', comp.semver, options) && this.operator.startsWith('<') && comp.operator.startsWith('>')) {
+	        return true;
+	      }
+	      return false;
+	    }
+	  }
+	  comparator = Comparator;
+	  const parseOptions = requireParseOptions();
+	  const {
+	    safeRe: re,
+	    t
+	  } = requireRe();
+	  const cmp = requireCmp();
+	  const debug = requireDebug();
+	  const SemVer = requireSemver();
+	  const Range = requireRange();
+	  return comparator;
 	}
 
 	var range;
 	var hasRequiredRange;
+	function requireRange() {
+	  if (hasRequiredRange) return range;
+	  hasRequiredRange = 1;
+	  const SPACE_CHARACTERS = /\s+/g;
+
+	  // hoisted class for cyclic dependency
+	  class Range {
+	    constructor(range, options) {
+	      options = parseOptions(options);
+	      if (range instanceof Range) {
+	        if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+	          return range;
+	        } else {
+	          return new Range(range.raw, options);
+	        }
+	      }
+	      if (range instanceof Comparator) {
+	        // just put it in the set and return
+	        this.raw = range.value;
+	        this.set = [[range]];
+	        this.formatted = undefined;
+	        return this;
+	      }
+	      this.options = options;
+	      this.loose = !!options.loose;
+	      this.includePrerelease = !!options.includePrerelease;
+
+	      // First reduce all whitespace as much as possible so we do not have to rely
+	      // on potentially slow regexes like \s*. This is then stored and used for
+	      // future error messages as well.
+	      this.raw = range.trim().replace(SPACE_CHARACTERS, ' ');
+
+	      // First, split on ||
+	      this.set = this.raw.split('||')
+	      // map the range to a 2d array of comparators
+	      .map(r => this.parseRange(r.trim()))
+	      // throw out any comparator lists that are empty
+	      // this generally means that it was not a valid range, which is allowed
+	      // in loose mode, but will still throw if the WHOLE range is invalid.
+	      .filter(c => c.length);
+	      if (!this.set.length) {
+	        throw new TypeError("Invalid SemVer Range: ".concat(this.raw));
+	      }
+
+	      // if we have any that are not the null set, throw out null sets.
+	      if (this.set.length > 1) {
+	        // keep the first one, in case they're all null sets
+	        const first = this.set[0];
+	        this.set = this.set.filter(c => !isNullSet(c[0]));
+	        if (this.set.length === 0) {
+	          this.set = [first];
+	        } else if (this.set.length > 1) {
+	          // if we have any that are *, then the range is just *
+	          for (const c of this.set) {
+	            if (c.length === 1 && isAny(c[0])) {
+	              this.set = [c];
+	              break;
+	            }
+	          }
+	        }
+	      }
+	      this.formatted = undefined;
+	    }
+	    get range() {
+	      if (this.formatted === undefined) {
+	        this.formatted = '';
+	        for (let i = 0; i < this.set.length; i++) {
+	          if (i > 0) {
+	            this.formatted += '||';
+	          }
+	          const comps = this.set[i];
+	          for (let k = 0; k < comps.length; k++) {
+	            if (k > 0) {
+	              this.formatted += ' ';
+	            }
+	            this.formatted += comps[k].toString().trim();
+	          }
+	        }
+	      }
+	      return this.formatted;
+	    }
+	    format() {
+	      return this.range;
+	    }
+	    toString() {
+	      return this.range;
+	    }
+	    parseRange(range) {
+	      // memoize range parsing for performance.
+	      // this is a very hot path, and fully deterministic.
+	      const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+	      const memoKey = memoOpts + ':' + range;
+	      const cached = cache.get(memoKey);
+	      if (cached) {
+	        return cached;
+	      }
+	      const loose = this.options.loose;
+	      // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+	      const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+	      range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+	      debug('hyphen replace', range);
+
+	      // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+	      range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+	      debug('comparator trim', range);
+
+	      // `~ 1.2.3` => `~1.2.3`
+	      range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+	      debug('tilde trim', range);
+
+	      // `^ 1.2.3` => `^1.2.3`
+	      range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+	      debug('caret trim', range);
+
+	      // At this point, the range is completely trimmed and
+	      // ready to be split into comparators.
+
+	      let rangeList = range.split(' ').map(comp => parseComparator(comp, this.options)).join(' ').split(/\s+/)
+	      // >=0.0.0 is equivalent to *
+	      .map(comp => replaceGTE0(comp, this.options));
+	      if (loose) {
+	        // in loose mode, throw out any that are not valid comparators
+	        rangeList = rangeList.filter(comp => {
+	          debug('loose invalid filter', comp, this.options);
+	          return !!comp.match(re[t.COMPARATORLOOSE]);
+	        });
+	      }
+	      debug('range list', rangeList);
 
-	function requireRange () {
-		if (hasRequiredRange) return range;
-		hasRequiredRange = 1;
-
-		const SPACE_CHARACTERS = /\s+/g;
-
-		// hoisted class for cyclic dependency
-		class Range {
-		  constructor (range, options) {
-		    options = parseOptions(options);
-
-		    if (range instanceof Range) {
-		      if (
-		        range.loose === !!options.loose &&
-		        range.includePrerelease === !!options.includePrerelease
-		      ) {
-		        return range
-		      } else {
-		        return new Range(range.raw, options)
-		      }
-		    }
-
-		    if (range instanceof Comparator) {
-		      // just put it in the set and return
-		      this.raw = range.value;
-		      this.set = [[range]];
-		      this.formatted = undefined;
-		      return this
-		    }
-
-		    this.options = options;
-		    this.loose = !!options.loose;
-		    this.includePrerelease = !!options.includePrerelease;
-
-		    // First reduce all whitespace as much as possible so we do not have to rely
-		    // on potentially slow regexes like \s*. This is then stored and used for
-		    // future error messages as well.
-		    this.raw = range.trim().replace(SPACE_CHARACTERS, ' ');
-
-		    // First, split on ||
-		    this.set = this.raw
-		      .split('||')
-		      // map the range to a 2d array of comparators
-		      .map(r => this.parseRange(r.trim()))
-		      // throw out any comparator lists that are empty
-		      // this generally means that it was not a valid range, which is allowed
-		      // in loose mode, but will still throw if the WHOLE range is invalid.
-		      .filter(c => c.length);
-
-		    if (!this.set.length) {
-		      throw new TypeError(`Invalid SemVer Range: ${this.raw}`)
-		    }
-
-		    // if we have any that are not the null set, throw out null sets.
-		    if (this.set.length > 1) {
-		      // keep the first one, in case they're all null sets
-		      const first = this.set[0];
-		      this.set = this.set.filter(c => !isNullSet(c[0]));
-		      if (this.set.length === 0) {
-		        this.set = [first];
-		      } else if (this.set.length > 1) {
-		        // if we have any that are *, then the range is just *
-		        for (const c of this.set) {
-		          if (c.length === 1 && isAny(c[0])) {
-		            this.set = [c];
-		            break
-		          }
-		        }
-		      }
-		    }
-
-		    this.formatted = undefined;
-		  }
-
-		  get range () {
-		    if (this.formatted === undefined) {
-		      this.formatted = '';
-		      for (let i = 0; i < this.set.length; i++) {
-		        if (i > 0) {
-		          this.formatted += '||';
-		        }
-		        const comps = this.set[i];
-		        for (let k = 0; k < comps.length; k++) {
-		          if (k > 0) {
-		            this.formatted += ' ';
-		          }
-		          this.formatted += comps[k].toString().trim();
-		        }
-		      }
-		    }
-		    return this.formatted
-		  }
-
-		  format () {
-		    return this.range
-		  }
-
-		  toString () {
-		    return this.range
-		  }
-
-		  parseRange (range) {
-		    // memoize range parsing for performance.
-		    // this is a very hot path, and fully deterministic.
-		    const memoOpts =
-		      (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) |
-		      (this.options.loose && FLAG_LOOSE);
-		    const memoKey = memoOpts + ':' + range;
-		    const cached = cache.get(memoKey);
-		    if (cached) {
-		      return cached
-		    }
-
-		    const loose = this.options.loose;
-		    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
-		    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
-		    range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
-		    debug('hyphen replace', range);
-
-		    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
-		    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
-		    debug('comparator trim', range);
-
-		    // `~ 1.2.3` => `~1.2.3`
-		    range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
-		    debug('tilde trim', range);
-
-		    // `^ 1.2.3` => `^1.2.3`
-		    range = range.replace(re[t.CARETTRIM], caretTrimReplace);
-		    debug('caret trim', range);
-
-		    // At this point, the range is completely trimmed and
-		    // ready to be split into comparators.
-
-		    let rangeList = range
-		      .split(' ')
-		      .map(comp => parseComparator(comp, this.options))
-		      .join(' ')
-		      .split(/\s+/)
-		      // >=0.0.0 is equivalent to *
-		      .map(comp => replaceGTE0(comp, this.options));
-
-		    if (loose) {
-		      // in loose mode, throw out any that are not valid comparators
-		      rangeList = rangeList.filter(comp => {
-		        debug('loose invalid filter', comp, this.options);
-		        return !!comp.match(re[t.COMPARATORLOOSE])
-		      });
-		    }
-		    debug('range list', rangeList);
-
-		    // if any comparators are the null set, then replace with JUST null set
-		    // if more than one comparator, remove any * comparators
-		    // also, don't include the same comparator more than once
-		    const rangeMap = new Map();
-		    const comparators = rangeList.map(comp => new Comparator(comp, this.options));
-		    for (const comp of comparators) {
-		      if (isNullSet(comp)) {
-		        return [comp]
-		      }
-		      rangeMap.set(comp.value, comp);
-		    }
-		    if (rangeMap.size > 1 && rangeMap.has('')) {
-		      rangeMap.delete('');
-		    }
-
-		    const result = [...rangeMap.values()];
-		    cache.set(memoKey, result);
-		    return result
-		  }
-
-		  intersects (range, options) {
-		    if (!(range instanceof Range)) {
-		      throw new TypeError('a Range is required')
-		    }
-
-		    return this.set.some((thisComparators) => {
-		      return (
-		        isSatisfiable(thisComparators, options) &&
-		        range.set.some((rangeComparators) => {
-		          return (
-		            isSatisfiable(rangeComparators, options) &&
-		            thisComparators.every((thisComparator) => {
-		              return rangeComparators.every((rangeComparator) => {
-		                return thisComparator.intersects(rangeComparator, options)
-		              })
-		            })
-		          )
-		        })
-		      )
-		    })
-		  }
-
-		  // if ANY of the sets match ALL of its comparators, then pass
-		  test (version) {
-		    if (!version) {
-		      return false
-		    }
-
-		    if (typeof version === 'string') {
-		      try {
-		        version = new SemVer(version, this.options);
-		      } catch (er) {
-		        return false
-		      }
-		    }
-
-		    for (let i = 0; i < this.set.length; i++) {
-		      if (testSet(this.set[i], version, this.options)) {
-		        return true
-		      }
-		    }
-		    return false
-		  }
-		}
-
-		range = Range;
-
-		const LRU = requireLrucache();
-		const cache = new LRU();
-
-		const parseOptions = requireParseOptions();
-		const Comparator = requireComparator();
-		const debug = requireDebug();
-		const SemVer = requireSemver();
-		const {
-		  safeRe: re,
-		  t,
-		  comparatorTrimReplace,
-		  tildeTrimReplace,
-		  caretTrimReplace,
-		} = requireRe();
-		const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = requireConstants();
-
-		const isNullSet = c => c.value === '<0.0.0-0';
-		const isAny = c => c.value === '';
-
-		// take a set of comparators and determine whether there
-		// exists a version which can satisfy it
-		const isSatisfiable = (comparators, options) => {
-		  let result = true;
-		  const remainingComparators = comparators.slice();
-		  let testComparator = remainingComparators.pop();
-
-		  while (result && remainingComparators.length) {
-		    result = remainingComparators.every((otherComparator) => {
-		      return testComparator.intersects(otherComparator, options)
-		    });
-
-		    testComparator = remainingComparators.pop();
-		  }
-
-		  return result
-		};
-
-		// comprised of xranges, tildes, stars, and gtlt's at this point.
-		// already replaced the hyphen ranges
-		// turn into a set of JUST comparators.
-		const parseComparator = (comp, options) => {
-		  debug('comp', comp, options);
-		  comp = replaceCarets(comp, options);
-		  debug('caret', comp);
-		  comp = replaceTildes(comp, options);
-		  debug('tildes', comp);
-		  comp = replaceXRanges(comp, options);
-		  debug('xrange', comp);
-		  comp = replaceStars(comp, options);
-		  debug('stars', comp);
-		  return comp
-		};
-
-		const isX = id => !id || id.toLowerCase() === 'x' || id === '*';
-
-		// ~, ~> --> * (any, kinda silly)
-		// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
-		// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
-		// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
-		// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
-		// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
-		// ~0.0.1 --> >=0.0.1 <0.1.0-0
-		const replaceTildes = (comp, options) => {
-		  return comp
-		    .trim()
-		    .split(/\s+/)
-		    .map((c) => replaceTilde(c, options))
-		    .join(' ')
-		};
-
-		const replaceTilde = (comp, options) => {
-		  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
-		  return comp.replace(r, (_, M, m, p, pr) => {
-		    debug('tilde', comp, _, M, m, p, pr);
-		    let ret;
-
-		    if (isX(M)) {
-		      ret = '';
-		    } else if (isX(m)) {
-		      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
-		    } else if (isX(p)) {
-		      // ~1.2 == >=1.2.0 <1.3.0-0
-		      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
-		    } else if (pr) {
-		      debug('replaceTilde pr', pr);
-		      ret = `>=${M}.${m}.${p}-${pr
-	      } <${M}.${+m + 1}.0-0`;
-		    } else {
-		      // ~1.2.3 == >=1.2.3 <1.3.0-0
-		      ret = `>=${M}.${m}.${p
-	      } <${M}.${+m + 1}.0-0`;
-		    }
-
-		    debug('tilde return', ret);
-		    return ret
-		  })
-		};
-
-		// ^ --> * (any, kinda silly)
-		// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
-		// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
-		// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
-		// ^1.2.3 --> >=1.2.3 <2.0.0-0
-		// ^1.2.0 --> >=1.2.0 <2.0.0-0
-		// ^0.0.1 --> >=0.0.1 <0.0.2-0
-		// ^0.1.0 --> >=0.1.0 <0.2.0-0
-		const replaceCarets = (comp, options) => {
-		  return comp
-		    .trim()
-		    .split(/\s+/)
-		    .map((c) => replaceCaret(c, options))
-		    .join(' ')
-		};
-
-		const replaceCaret = (comp, options) => {
-		  debug('caret', comp, options);
-		  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
-		  const z = options.includePrerelease ? '-0' : '';
-		  return comp.replace(r, (_, M, m, p, pr) => {
-		    debug('caret', comp, _, M, m, p, pr);
-		    let ret;
-
-		    if (isX(M)) {
-		      ret = '';
-		    } else if (isX(m)) {
-		      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
-		    } else if (isX(p)) {
-		      if (M === '0') {
-		        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
-		      } else {
-		        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
-		      }
-		    } else if (pr) {
-		      debug('replaceCaret pr', pr);
-		      if (M === '0') {
-		        if (m === '0') {
-		          ret = `>=${M}.${m}.${p}-${pr
-	          } <${M}.${m}.${+p + 1}-0`;
-		        } else {
-		          ret = `>=${M}.${m}.${p}-${pr
-	          } <${M}.${+m + 1}.0-0`;
-		        }
-		      } else {
-		        ret = `>=${M}.${m}.${p}-${pr
-	        } <${+M + 1}.0.0-0`;
-		      }
-		    } else {
-		      debug('no pr');
-		      if (M === '0') {
-		        if (m === '0') {
-		          ret = `>=${M}.${m}.${p
-	          }${z} <${M}.${m}.${+p + 1}-0`;
-		        } else {
-		          ret = `>=${M}.${m}.${p
-	          }${z} <${M}.${+m + 1}.0-0`;
-		        }
-		      } else {
-		        ret = `>=${M}.${m}.${p
-	        } <${+M + 1}.0.0-0`;
-		      }
-		    }
-
-		    debug('caret return', ret);
-		    return ret
-		  })
-		};
-
-		const replaceXRanges = (comp, options) => {
-		  debug('replaceXRanges', comp, options);
-		  return comp
-		    .split(/\s+/)
-		    .map((c) => replaceXRange(c, options))
-		    .join(' ')
-		};
-
-		const replaceXRange = (comp, options) => {
-		  comp = comp.trim();
-		  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
-		  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
-		    debug('xRange', comp, ret, gtlt, M, m, p, pr);
-		    const xM = isX(M);
-		    const xm = xM || isX(m);
-		    const xp = xm || isX(p);
-		    const anyX = xp;
-
-		    if (gtlt === '=' && anyX) {
-		      gtlt = '';
-		    }
-
-		    // if we're including prereleases in the match, then we need
-		    // to fix this to -0, the lowest possible prerelease value
-		    pr = options.includePrerelease ? '-0' : '';
-
-		    if (xM) {
-		      if (gtlt === '>' || gtlt === '<') {
-		        // nothing is allowed
-		        ret = '<0.0.0-0';
-		      } else {
-		        // nothing is forbidden
-		        ret = '*';
-		      }
-		    } else if (gtlt && anyX) {
-		      // we know patch is an x, because we have any x at all.
-		      // replace X with 0
-		      if (xm) {
-		        m = 0;
-		      }
-		      p = 0;
-
-		      if (gtlt === '>') {
-		        // >1 => >=2.0.0
-		        // >1.2 => >=1.3.0
-		        gtlt = '>=';
-		        if (xm) {
-		          M = +M + 1;
-		          m = 0;
-		          p = 0;
-		        } else {
-		          m = +m + 1;
-		          p = 0;
-		        }
-		      } else if (gtlt === '<=') {
-		        // <=0.7.x is actually <0.8.0, since any 0.7.x should
-		        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
-		        gtlt = '<';
-		        if (xm) {
-		          M = +M + 1;
-		        } else {
-		          m = +m + 1;
-		        }
-		      }
-
-		      if (gtlt === '<') {
-		        pr = '-0';
-		      }
-
-		      ret = `${gtlt + M}.${m}.${p}${pr}`;
-		    } else if (xm) {
-		      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
-		    } else if (xp) {
-		      ret = `>=${M}.${m}.0${pr
-	      } <${M}.${+m + 1}.0-0`;
-		    }
-
-		    debug('xRange return', ret);
-
-		    return ret
-		  })
-		};
-
-		// Because * is AND-ed with everything else in the comparator,
-		// and '' means "any version", just remove the *s entirely.
-		const replaceStars = (comp, options) => {
-		  debug('replaceStars', comp, options);
-		  // Looseness is ignored here.  star is always as loose as it gets!
-		  return comp
-		    .trim()
-		    .replace(re[t.STAR], '')
-		};
-
-		const replaceGTE0 = (comp, options) => {
-		  debug('replaceGTE0', comp, options);
-		  return comp
-		    .trim()
-		    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
-		};
-
-		// This function is passed to string.replace(re[t.HYPHENRANGE])
-		// M, m, patch, prerelease, build
-		// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
-		// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
-		// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
-		// TODO build?
-		const hyphenReplace = incPr => ($0,
-		  from, fM, fm, fp, fpr, fb,
-		  to, tM, tm, tp, tpr) => {
-		  if (isX(fM)) {
-		    from = '';
-		  } else if (isX(fm)) {
-		    from = `>=${fM}.0.0${incPr ? '-0' : ''}`;
-		  } else if (isX(fp)) {
-		    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`;
-		  } else if (fpr) {
-		    from = `>=${from}`;
-		  } else {
-		    from = `>=${from}${incPr ? '-0' : ''}`;
-		  }
-
-		  if (isX(tM)) {
-		    to = '';
-		  } else if (isX(tm)) {
-		    to = `<${+tM + 1}.0.0-0`;
-		  } else if (isX(tp)) {
-		    to = `<${tM}.${+tm + 1}.0-0`;
-		  } else if (tpr) {
-		    to = `<=${tM}.${tm}.${tp}-${tpr}`;
-		  } else if (incPr) {
-		    to = `<${tM}.${tm}.${+tp + 1}-0`;
-		  } else {
-		    to = `<=${to}`;
-		  }
-
-		  return `${from} ${to}`.trim()
-		};
+	      // if any comparators are the null set, then replace with JUST null set
+	      // if more than one comparator, remove any * comparators
+	      // also, don't include the same comparator more than once
+	      const rangeMap = new Map();
+	      const comparators = rangeList.map(comp => new Comparator(comp, this.options));
+	      for (const comp of comparators) {
+	        if (isNullSet(comp)) {
+	          return [comp];
+	        }
+	        rangeMap.set(comp.value, comp);
+	      }
+	      if (rangeMap.size > 1 && rangeMap.has('')) {
+	        rangeMap.delete('');
+	      }
+	      const result = [...rangeMap.values()];
+	      cache.set(memoKey, result);
+	      return result;
+	    }
+	    intersects(range, options) {
+	      if (!(range instanceof Range)) {
+	        throw new TypeError('a Range is required');
+	      }
+	      return this.set.some(thisComparators => {
+	        return isSatisfiable(thisComparators, options) && range.set.some(rangeComparators => {
+	          return isSatisfiable(rangeComparators, options) && thisComparators.every(thisComparator => {
+	            return rangeComparators.every(rangeComparator => {
+	              return thisComparator.intersects(rangeComparator, options);
+	            });
+	          });
+	        });
+	      });
+	    }
 
-		const testSet = (set, version, options) => {
-		  for (let i = 0; i < set.length; i++) {
-		    if (!set[i].test(version)) {
-		      return false
-		    }
-		  }
+	    // if ANY of the sets match ALL of its comparators, then pass
+	    test(version) {
+	      if (!version) {
+	        return false;
+	      }
+	      if (typeof version === 'string') {
+	        try {
+	          version = new SemVer(version, this.options);
+	        } catch (er) {
+	          return false;
+	        }
+	      }
+	      for (let i = 0; i < this.set.length; i++) {
+	        if (testSet(this.set[i], version, this.options)) {
+	          return true;
+	        }
+	      }
+	      return false;
+	    }
+	  }
+	  range = Range;
+	  const LRU = requireLrucache();
+	  const cache = new LRU();
+	  const parseOptions = requireParseOptions();
+	  const Comparator = requireComparator();
+	  const debug = requireDebug();
+	  const SemVer = requireSemver();
+	  const {
+	    safeRe: re,
+	    t,
+	    comparatorTrimReplace,
+	    tildeTrimReplace,
+	    caretTrimReplace
+	  } = requireRe();
+	  const {
+	    FLAG_INCLUDE_PRERELEASE,
+	    FLAG_LOOSE
+	  } = requireConstants();
+	  const isNullSet = c => c.value === '<0.0.0-0';
+	  const isAny = c => c.value === '';
+
+	  // take a set of comparators and determine whether there
+	  // exists a version which can satisfy it
+	  const isSatisfiable = (comparators, options) => {
+	    let result = true;
+	    const remainingComparators = comparators.slice();
+	    let testComparator = remainingComparators.pop();
+	    while (result && remainingComparators.length) {
+	      result = remainingComparators.every(otherComparator => {
+	        return testComparator.intersects(otherComparator, options);
+	      });
+	      testComparator = remainingComparators.pop();
+	    }
+	    return result;
+	  };
 
-		  if (version.prerelease.length && !options.includePrerelease) {
-		    // Find the set of versions that are allowed to have prereleases
-		    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
-		    // That should allow `1.2.3-pr.2` to pass.
-		    // However, `1.2.4-alpha.notready` should NOT be allowed,
-		    // even though it's within the range set by the comparators.
-		    for (let i = 0; i < set.length; i++) {
-		      debug(set[i].semver);
-		      if (set[i].semver === Comparator.ANY) {
-		        continue
-		      }
+	  // comprised of xranges, tildes, stars, and gtlt's at this point.
+	  // already replaced the hyphen ranges
+	  // turn into a set of JUST comparators.
+	  const parseComparator = (comp, options) => {
+	    debug('comp', comp, options);
+	    comp = replaceCarets(comp, options);
+	    debug('caret', comp);
+	    comp = replaceTildes(comp, options);
+	    debug('tildes', comp);
+	    comp = replaceXRanges(comp, options);
+	    debug('xrange', comp);
+	    comp = replaceStars(comp, options);
+	    debug('stars', comp);
+	    return comp;
+	  };
+	  const isX = id => !id || id.toLowerCase() === 'x' || id === '*';
+
+	  // ~, ~> --> * (any, kinda silly)
+	  // ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
+	  // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
+	  // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
+	  // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
+	  // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
+	  // ~0.0.1 --> >=0.0.1 <0.1.0-0
+	  const replaceTildes = (comp, options) => {
+	    return comp.trim().split(/\s+/).map(c => replaceTilde(c, options)).join(' ');
+	  };
+	  const replaceTilde = (comp, options) => {
+	    const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+	    return comp.replace(r, (_, M, m, p, pr) => {
+	      debug('tilde', comp, _, M, m, p, pr);
+	      let ret;
+	      if (isX(M)) {
+	        ret = '';
+	      } else if (isX(m)) {
+	        ret = ">=".concat(M, ".0.0 <").concat(+M + 1, ".0.0-0");
+	      } else if (isX(p)) {
+	        // ~1.2 == >=1.2.0 <1.3.0-0
+	        ret = ">=".concat(M, ".").concat(m, ".0 <").concat(M, ".").concat(+m + 1, ".0-0");
+	      } else if (pr) {
+	        debug('replaceTilde pr', pr);
+	        ret = ">=".concat(M, ".").concat(m, ".").concat(p, "-").concat(pr, " <").concat(M, ".").concat(+m + 1, ".0-0");
+	      } else {
+	        // ~1.2.3 == >=1.2.3 <1.3.0-0
+	        ret = ">=".concat(M, ".").concat(m, ".").concat(p, " <").concat(M, ".").concat(+m + 1, ".0-0");
+	      }
+	      debug('tilde return', ret);
+	      return ret;
+	    });
+	  };
 
-		      if (set[i].semver.prerelease.length > 0) {
-		        const allowed = set[i].semver;
-		        if (allowed.major === version.major &&
-		            allowed.minor === version.minor &&
-		            allowed.patch === version.patch) {
-		          return true
-		        }
-		      }
-		    }
+	  // ^ --> * (any, kinda silly)
+	  // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
+	  // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
+	  // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
+	  // ^1.2.3 --> >=1.2.3 <2.0.0-0
+	  // ^1.2.0 --> >=1.2.0 <2.0.0-0
+	  // ^0.0.1 --> >=0.0.1 <0.0.2-0
+	  // ^0.1.0 --> >=0.1.0 <0.2.0-0
+	  const replaceCarets = (comp, options) => {
+	    return comp.trim().split(/\s+/).map(c => replaceCaret(c, options)).join(' ');
+	  };
+	  const replaceCaret = (comp, options) => {
+	    debug('caret', comp, options);
+	    const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+	    const z = options.includePrerelease ? '-0' : '';
+	    return comp.replace(r, (_, M, m, p, pr) => {
+	      debug('caret', comp, _, M, m, p, pr);
+	      let ret;
+	      if (isX(M)) {
+	        ret = '';
+	      } else if (isX(m)) {
+	        ret = ">=".concat(M, ".0.0").concat(z, " <").concat(+M + 1, ".0.0-0");
+	      } else if (isX(p)) {
+	        if (M === '0') {
+	          ret = ">=".concat(M, ".").concat(m, ".0").concat(z, " <").concat(M, ".").concat(+m + 1, ".0-0");
+	        } else {
+	          ret = ">=".concat(M, ".").concat(m, ".0").concat(z, " <").concat(+M + 1, ".0.0-0");
+	        }
+	      } else if (pr) {
+	        debug('replaceCaret pr', pr);
+	        if (M === '0') {
+	          if (m === '0') {
+	            ret = ">=".concat(M, ".").concat(m, ".").concat(p, "-").concat(pr, " <").concat(M, ".").concat(m, ".").concat(+p + 1, "-0");
+	          } else {
+	            ret = ">=".concat(M, ".").concat(m, ".").concat(p, "-").concat(pr, " <").concat(M, ".").concat(+m + 1, ".0-0");
+	          }
+	        } else {
+	          ret = ">=".concat(M, ".").concat(m, ".").concat(p, "-").concat(pr, " <").concat(+M + 1, ".0.0-0");
+	        }
+	      } else {
+	        debug('no pr');
+	        if (M === '0') {
+	          if (m === '0') {
+	            ret = ">=".concat(M, ".").concat(m, ".").concat(p).concat(z, " <").concat(M, ".").concat(m, ".").concat(+p + 1, "-0");
+	          } else {
+	            ret = ">=".concat(M, ".").concat(m, ".").concat(p).concat(z, " <").concat(M, ".").concat(+m + 1, ".0-0");
+	          }
+	        } else {
+	          ret = ">=".concat(M, ".").concat(m, ".").concat(p, " <").concat(+M + 1, ".0.0-0");
+	        }
+	      }
+	      debug('caret return', ret);
+	      return ret;
+	    });
+	  };
+	  const replaceXRanges = (comp, options) => {
+	    debug('replaceXRanges', comp, options);
+	    return comp.split(/\s+/).map(c => replaceXRange(c, options)).join(' ');
+	  };
+	  const replaceXRange = (comp, options) => {
+	    comp = comp.trim();
+	    const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+	    return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+	      debug('xRange', comp, ret, gtlt, M, m, p, pr);
+	      const xM = isX(M);
+	      const xm = xM || isX(m);
+	      const xp = xm || isX(p);
+	      const anyX = xp;
+	      if (gtlt === '=' && anyX) {
+	        gtlt = '';
+	      }
+
+	      // if we're including prereleases in the match, then we need
+	      // to fix this to -0, the lowest possible prerelease value
+	      pr = options.includePrerelease ? '-0' : '';
+	      if (xM) {
+	        if (gtlt === '>' || gtlt === '<') {
+	          // nothing is allowed
+	          ret = '<0.0.0-0';
+	        } else {
+	          // nothing is forbidden
+	          ret = '*';
+	        }
+	      } else if (gtlt && anyX) {
+	        // we know patch is an x, because we have any x at all.
+	        // replace X with 0
+	        if (xm) {
+	          m = 0;
+	        }
+	        p = 0;
+	        if (gtlt === '>') {
+	          // >1 => >=2.0.0
+	          // >1.2 => >=1.3.0
+	          gtlt = '>=';
+	          if (xm) {
+	            M = +M + 1;
+	            m = 0;
+	            p = 0;
+	          } else {
+	            m = +m + 1;
+	            p = 0;
+	          }
+	        } else if (gtlt === '<=') {
+	          // <=0.7.x is actually <0.8.0, since any 0.7.x should
+	          // pass.  Similarly, <=7.x is actually <8.0.0, etc.
+	          gtlt = '<';
+	          if (xm) {
+	            M = +M + 1;
+	          } else {
+	            m = +m + 1;
+	          }
+	        }
+	        if (gtlt === '<') {
+	          pr = '-0';
+	        }
+	        ret = "".concat(gtlt + M, ".").concat(m, ".").concat(p).concat(pr);
+	      } else if (xm) {
+	        ret = ">=".concat(M, ".0.0").concat(pr, " <").concat(+M + 1, ".0.0-0");
+	      } else if (xp) {
+	        ret = ">=".concat(M, ".").concat(m, ".0").concat(pr, " <").concat(M, ".").concat(+m + 1, ".0-0");
+	      }
+	      debug('xRange return', ret);
+	      return ret;
+	    });
+	  };
 
-		    // Version has a -pre, but it's not one of the ones we like.
-		    return false
-		  }
+	  // Because * is AND-ed with everything else in the comparator,
+	  // and '' means "any version", just remove the *s entirely.
+	  const replaceStars = (comp, options) => {
+	    debug('replaceStars', comp, options);
+	    // Looseness is ignored here.  star is always as loose as it gets!
+	    return comp.trim().replace(re[t.STAR], '');
+	  };
+	  const replaceGTE0 = (comp, options) => {
+	    debug('replaceGTE0', comp, options);
+	    return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '');
+	  };
+
+	  // This function is passed to string.replace(re[t.HYPHENRANGE])
+	  // M, m, patch, prerelease, build
+	  // 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+	  // 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
+	  // 1.2 - 3.4 => >=1.2.0 <3.5.0-0
+	  // TODO build?
+	  const hyphenReplace = incPr => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+	    if (isX(fM)) {
+	      from = '';
+	    } else if (isX(fm)) {
+	      from = ">=".concat(fM, ".0.0").concat(incPr ? '-0' : '');
+	    } else if (isX(fp)) {
+	      from = ">=".concat(fM, ".").concat(fm, ".0").concat(incPr ? '-0' : '');
+	    } else if (fpr) {
+	      from = ">=".concat(from);
+	    } else {
+	      from = ">=".concat(from).concat(incPr ? '-0' : '');
+	    }
+	    if (isX(tM)) {
+	      to = '';
+	    } else if (isX(tm)) {
+	      to = "<".concat(+tM + 1, ".0.0-0");
+	    } else if (isX(tp)) {
+	      to = "<".concat(tM, ".").concat(+tm + 1, ".0-0");
+	    } else if (tpr) {
+	      to = "<=".concat(tM, ".").concat(tm, ".").concat(tp, "-").concat(tpr);
+	    } else if (incPr) {
+	      to = "<".concat(tM, ".").concat(tm, ".").concat(+tp + 1, "-0");
+	    } else {
+	      to = "<=".concat(to);
+	    }
+	    return "".concat(from, " ").concat(to).trim();
+	  };
+	  const testSet = (set, version, options) => {
+	    for (let i = 0; i < set.length; i++) {
+	      if (!set[i].test(version)) {
+	        return false;
+	      }
+	    }
+	    if (version.prerelease.length && !options.includePrerelease) {
+	      // Find the set of versions that are allowed to have prereleases
+	      // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+	      // That should allow `1.2.3-pr.2` to pass.
+	      // However, `1.2.4-alpha.notready` should NOT be allowed,
+	      // even though it's within the range set by the comparators.
+	      for (let i = 0; i < set.length; i++) {
+	        debug(set[i].semver);
+	        if (set[i].semver === Comparator.ANY) {
+	          continue;
+	        }
+	        if (set[i].semver.prerelease.length > 0) {
+	          const allowed = set[i].semver;
+	          if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
+	            return true;
+	          }
+	        }
+	      }
 
-		  return true
-		};
-		return range;
+	      // Version has a -pre, but it's not one of the ones we like.
+	      return false;
+	    }
+	    return true;
+	  };
+	  return range;
 	}
 
 	var satisfies_1;
 	var hasRequiredSatisfies;
-
-	function requireSatisfies () {
-		if (hasRequiredSatisfies) return satisfies_1;
-		hasRequiredSatisfies = 1;
-
-		const Range = requireRange();
-		const satisfies = (version, range, options) => {
-		  try {
-		    range = new Range(range, options);
-		  } catch (er) {
-		    return false
-		  }
-		  return range.test(version)
-		};
-		satisfies_1 = satisfies;
-		return satisfies_1;
+	function requireSatisfies() {
+	  if (hasRequiredSatisfies) return satisfies_1;
+	  hasRequiredSatisfies = 1;
+	  const Range = requireRange();
+	  const satisfies = (version, range, options) => {
+	    try {
+	      range = new Range(range, options);
+	    } catch (er) {
+	      return false;
+	    }
+	    return range.test(version);
+	  };
+	  satisfies_1 = satisfies;
+	  return satisfies_1;
 	}
 
 	var satisfiesExports = requireSatisfies();