@nebula.js/stardust 2.6.1 → 2.7.0

package/dist/stardust.dev.js

@@ -1,5 +1,5 @@
 /*
-* @nebula.js/stardust v2.6.1
+* @nebula.js/stardust v2.7.0
 * Copyright (c) 2022 QlikTech International AB
 * Released under the MIT license.
 */
@@ -743,14 +743,9 @@
 
     if (Object.getOwnPropertySymbols) {
       var symbols = Object.getOwnPropertySymbols(object);
-
-      if (enumerableOnly) {
-        symbols = symbols.filter(function (sym) {
-          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-        });
-      }
-
-      keys.push.apply(keys, symbols);
+      enumerableOnly && (symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      })), keys.push.apply(keys, symbols);
     }
 
     return keys;
@@ -758,19 +753,12 @@
 
   function _objectSpread2(target) {
     for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i] != null ? arguments[i] : {};
-
-      if (i % 2) {
-        ownKeys(Object(source), true).forEach(function (key) {
-          _defineProperty$2(target, key, source[key]);
-        });
-      } else if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-      } else {
-        ownKeys(Object(source)).forEach(function (key) {
-          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
-      }
+      var source = null != arguments[i] ? arguments[i] : {};
+      i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+        _defineProperty$2(target, key, source[key]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
     }
 
     return target;
@@ -1002,6 +990,26 @@
   		"zh-TW": "{0}/ {1}"
   	}
   };
+  var Listbox_Lock = {
+  	id: "Listbox.Lock",
+  	locale: {
+  		"de-DE": "Auswahlen sperren",
+  		"en-US": "Lock selections",
+  		"es-ES": "Bloquear selecciones",
+  		"fr-FR": "Verrouiller les sélections",
+  		"it-IT": "Blocca selezioni",
+  		"ja-JP": "選択をロック",
+  		"ko-KR": "선택 내용 잠금",
+  		"nl-NL": "Selecties vergrendelen",
+  		"pl-PL": "Zablokuj wybory",
+  		"pt-BR": "Bloquear seleções",
+  		"ru-RU": "Заблокировать выборки",
+  		"sv-SE": "Lås urval",
+  		"tr-TR": "Seçimleri kilitle",
+  		"zh-CN": "锁定选择项",
+  		"zh-TW": "鎖定選項"
+  	}
+  };
   var Listbox_Search = {
   	id: "Listbox.Search",
   	locale: {
@@ -1022,6 +1030,26 @@
   		"zh-TW": "在清單方塊中搜尋"
   	}
   };
+  var Listbox_Unlock = {
+  	id: "Listbox.Unlock",
+  	locale: {
+  		"de-DE": "Auswahlen entsperren",
+  		"en-US": "Unlock selections",
+  		"es-ES": "Desbloquear selecciones",
+  		"fr-FR": "Déverrouiller les sélections",
+  		"it-IT": "Sblocca selezioni",
+  		"ja-JP": "選択をロック解除",
+  		"ko-KR": "선택 내용 잠금 해제",
+  		"nl-NL": "Selecties ontgrendelen",
+  		"pl-PL": "Odblokuj wybory",
+  		"pt-BR": "Desbloquear seleções",
+  		"ru-RU": "Разблокировать выборки",
+  		"sv-SE": "Lås upp urval",
+  		"tr-TR": "Seçimlerin kilidini aç",
+  		"zh-CN": "将选择项解锁",
+  		"zh-TW": "解鎖選項"
+  	}
+  };
   var Menu_More = {
   	id: "Menu.More",
   	locale: {
@@ -1506,7 +1534,9 @@
   	Cancel: Cancel$1,
   	CurrentSelections_All: CurrentSelections_All,
   	CurrentSelections_Of: CurrentSelections_Of,
+  	Listbox_Lock: Listbox_Lock,
   	Listbox_Search: Listbox_Search,
+  	Listbox_Unlock: Listbox_Unlock,
   	Menu_More: Menu_More,
   	Navigate_Back: Navigate_Back,
   	Navigate_Forward: Navigate_Forward,
@@ -2929,7 +2959,7 @@
   }
 
   /**
-   * Creates the follwing array of paths
+   * Creates the following array of paths
    * object.barChart - legend.title - fontSize
    * object - legend.title - fontSize
    * legend.title - fontSize
@@ -2984,7 +3014,7 @@
       if (obj[steps[i]]) {
         obj = obj[steps[i]];
       } else {
-        return null;
+        return undefined;
       }
     }
 
@@ -2992,12 +3022,11 @@
   }
 
   function searchPathArray(pathArray, attribute, theme) {
-    for (let i = 0; i < pathArray.length; i++) {
-      const target = getObject$1(theme, pathArray[i]);
+    const attributeArray = attribute.split('.');
 
-      if (target !== null && target[attribute]) {
-        return target[attribute];
-      }
+    for (let i = 0; i < pathArray.length; i++) {
+      const restult = getObject$1(theme, [...pathArray[i], ...attributeArray]);
+      if (restult !== undefined) return restult;
     }
 
     return undefined;
@@ -3033,11 +3062,15 @@
        * object.barChart - fontSize
        * object - fontSize
        * fontSize
+       * When attributes separated by dots is provided, they are required in the theme JSON file
+       * Ex. Base path: "object" , Path: "legend", ", Attribute: "title.fontSize"
+       * title: {fontSize: ...} must be matched and the rest is the same as above
+       * If you want a exact match, you can use `getStyle('object', '', 'legend.title.fontSize');`
        * @ignore
        *
-       * @param {string} component string of properties seperated by dots to search in
-       * @param {string} attribute to return
-       * @returns {any} value of the resolved path, undefined if not found
+       * @param {string} component String of properties separated by dots to search in
+       * @param {string} attribute Name of the style attribute
+       * @returns {string|undefined} The style value of the resolved path, undefined if not found
        */
       getStyle(component, attribute) {
         // TODO - object overrides
@@ -3200,17 +3233,23 @@
       },
 
       /**
-       * Get the value of a style attribute in the theme by searching in the theme's JSON structure.
-       * The search starts at the specified base path and continues upwards until the value is found.
+       * Get the value of a style attribute in the theme
+       * by searching in the theme's JSON structure.
+       * The search starts at the specified base path
+       * and continues upwards until the value is found.
        * If possible it will get the attribute's value using the given path.
+       * When attributes separated by dots are provided, such as 'hover.color',
+       * they are required in the theme JSON file
        *
        * @param {string} basePath - Base path in the theme's JSON structure to start the search in (specified as a name path separated by dots).
        * @param {string} path - Expected path for the attribute (specified as a name path separated by dots).
-       * @param {string} attribute - Name of the style attribute.
-       * @returns {string} The style value
+       * @param {string} attribute - Name of the style attribute. (specified as a name attribute separated by dots).
+       * @returns {string|undefined} The style value or undefined if not found
        *
        * @example
        * theme.getStyle('object', 'title.main', 'fontSize');
+       * theme.getStyle('object', 'title', 'main.fontSize');
+       * theme.getStyle('object', '', 'title.main.fontSize');
        * theme.getStyle('', '', 'fontSize');
        */
       getStyle(basePath, path, attribute) {
@@ -3218,7 +3257,7 @@
           styleResolverInstanceCache[basePath] = styleResolver(basePath, resolvedThemeJSON);
         }
 
-        return styleResolverInstanceCache[basePath].getStyle(path, attribute, false);
+        return styleResolverInstanceCache[basePath].getStyle(path, attribute);
       }
 
     };
@@ -3257,7 +3296,9 @@
 
   /* eslint no-underscore-dangle:0 */
 
-  const timed = (t, v) => new Promise(resolve => setTimeout(() => resolve(v), t));
+  const timed = (t, v) => new Promise(resolve => {
+    setTimeout(() => resolve(v), t);
+  });
 
   const LOAD_THEME_TIMEOUT = 5000;
   function appTheme() {
@@ -11023,7 +11064,7 @@
     return [appSelections, navState];
   }
 
-  const NEBULA_VERSION_HASH = "375a" ;
+  const NEBULA_VERSION_HASH = "b1d7" ;
   let counter = 0;
   const NebulaApp = react.exports.forwardRef((_ref, ref) => {
     let {
@@ -11069,7 +11110,7 @@
       theme: theme
     }, /*#__PURE__*/React.createElement(InstanceContext.Provider, {
       value: context
-    }, /*#__PURE__*/React.createElement(React.Fragment, null, components))));
+    }, components)));
   });
   function boot(_ref2) {
     let {
@@ -11083,7 +11124,7 @@
     const appRef = React.createRef();
     const element = document.createElement('div');
     element.style.display = 'none';
-    element.setAttribute('data-nebulajs-version', "2.6.1" );
+    element.setAttribute('data-nebulajs-version', "2.7.0" );
     element.setAttribute('data-app-id', app.id);
     document.body.appendChild(element);
     ReactDOM.render( /*#__PURE__*/React.createElement(NebulaApp, {
@@ -18896,7 +18937,8 @@
     return elemNumbers;
   }
   /**
-   * @typedef {object} MinMaxResult
+   * @ignore
+   * @interface MinMaxResult
    * @property {number} min
    * @property {number} max
    */
@@ -18905,6 +18947,7 @@
    * Returns the min and max indices of elemNumbersOrdered which contains
    * all numbers in elementNbrs.
    *
+   * @ignore
    * @param {number[]} elementNbrs
    * @param {number[]} elemNumbersOrdered
    * @returns {MinMaxResult}
@@ -18948,6 +18991,7 @@
       pages = [],
       rangeSelect = true,
       checkboxes = false,
+      selectDisabled,
       doc = document
     } = _ref;
     const [instantPages, setInstantPages] = react.exports.useState(pages);
@@ -18964,6 +19008,11 @@
     const select = async function () {
       let elemNumbers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
       let additive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+      if (selectDisabled()) {
+        return;
+      }
+
       setSelectingValues(true);
       const isSingleSelect = getIsSingleSelect();
       const filtered = additive ? elemNumbers.filter(n => !selected.includes(n)) : elemNumbers;
@@ -18978,6 +19027,11 @@
 
     const preSelect = function (elemNumbers) {
       let additive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+      if (selectDisabled()) {
+        return;
+      }
+
       setPreSelected(existing => {
         const uniques = getUniques([...existing, ...elemNumbers]);
         const filtered = additive ? uniques.filter(n => !selected.includes(n)) : uniques;
@@ -18986,16 +19040,26 @@
       });
     };
 
+    const selectManually = function () {
+      let elementIds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      let additive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      setMouseDown(true);
+      preSelect(elementIds, additive || isRangeSelection);
+      const p = select(elementIds, additive || isRangeSelection);
+      setMouseDown(false);
+      return p;
+    };
+
     const onClick = react.exports.useCallback(event => {
-      if (selectingValues) {
+      if (selectingValues || selectDisabled()) {
         return;
       }
 
       const elemNumber = +event.currentTarget.getAttribute('data-n');
       setPreSelected([elemNumber]);
-    }, [selectingValues]);
+    }, [selectingValues, selectDisabled]);
     const onMouseDown = react.exports.useCallback(event => {
-      if (selectingValues) {
+      if (selectingValues || selectDisabled()) {
         return;
       }
 
@@ -19003,7 +19067,7 @@
       setMouseDown(true);
       const elemNumber = +event.currentTarget.getAttribute('data-n');
       setPreSelected([elemNumber]);
-    }, [selectingValues]);
+    }, [selectingValues, selectDisabled]);
     const onMouseUp = react.exports.useCallback(event => {
       const elemNumber = +event.currentTarget.getAttribute('data-n');
 
@@ -19013,21 +19077,21 @@
       }
 
       preSelect([elemNumber]);
-    }, [mouseDown, selectingValues, preSelected, selected, isRangeSelection]);
+    }, [mouseDown, selectingValues, preSelected, selected, isRangeSelection, selectDisabled]);
     const onMouseUpDoc = react.exports.useCallback(() => {
       // Ensure we end interactions when mouseup happens outside the Listbox.
       setMouseDown(false);
       setSelectingValues(false);
     }, []);
     const onMouseEnter = react.exports.useCallback(event => {
-      if (getIsSingleSelect() || !mouseDown || selectingValues) {
+      if (getIsSingleSelect() || !mouseDown || selectingValues || selectDisabled()) {
         return;
       }
 
       setIsRangeSelection(true);
       const elemNumber = +event.currentTarget.getAttribute('data-n');
       preSelect([elemNumber], true);
-    }, [mouseDown, selectingValues, isRangeSelection, preSelected, selected, layout && layout.qListObject.qDimensionInfo.qIsOneAndOnlyOne]);
+    }, [mouseDown, selectingValues, isRangeSelection, preSelected, selected, selectDisabled, layout && layout.qListObject.qDimensionInfo.qIsOneAndOnlyOne]);
     react.exports.useEffect(() => {
       // Perform selections of pre-selected values. This can
       // happen only when interactions have finished (mouseup).
@@ -19038,7 +19102,7 @@
       }
 
       select(preSelected, isRangeSelection);
-    }, [preSelected, mouseDown]);
+    }, [preSelected, mouseDown, selectDisabled()]);
     react.exports.useEffect(() => {
       doc.addEventListener('mouseup', onMouseUpDoc);
       return () => {
@@ -19084,7 +19148,9 @@
 
     return {
       instantPages,
-      interactionEvents
+      interactionEvents,
+      select: selectManually // preselect and select without having to trigger an event
+
     };
   }
 
@@ -19101,7 +19167,7 @@
 
   const CheckboxChecked = "url(\"data:image/svg+xml;charset=utf-8,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Cpath" + " fill-rule='evenodd' clip-rule='evenodd' d='M12 5c-.28 0-.53.11-.71.29L7 9.59l-2.29-2.3a1.003 " + "1.003 0 00-1.42 1.42l3 3c.18.18.43.29.71.29s.53-.11.71-.29l5-5A1.003 1.003 0 0012 5z' fill='%23fff'/%3E%3C/svg%3E\")";
 
-  const useStyles$b = makeStyles$1(theme => ({
+  const useStyles$c = makeStyles$1(theme => ({
     cbIcon: {
       borderRadius: 3,
       width: 16,
@@ -19138,11 +19204,10 @@
       label,
       dense
     } = _ref;
-    const styles = useStyles$b();
+    const styles = useStyles$c();
     return /*#__PURE__*/React.createElement(Checkbox$1, {
       edge: "start",
       checked: checked,
-      tabIndex: -1,
       disableRipple: true,
       className: [styles.checkbox, dense && styles.dense].filter(Boolean).join(' '),
       inputProps: {
@@ -19159,18 +19224,21 @@
   }
 
   /**
-   * @typedef {object} Range
+   * @ignore
+   * @interface Range
    * @property {number} qCharPos The (absolute) index where the highlighted range starts.
    * @property {number} qCharCount The length of the sub-string (starting from qChartPos) that should be highlighted.
    */
 
   /**
-   * @typedef {object} Segment
+   * @ignore
+   * @interface Segment
    * @property {string} segment The sub-string/segment cut out from the original label.
    * @property {boolean} highlighted A flag which tells whether the segment should be highlighted or not.
    */
 
   /**
+   * @ignore
    * @param {string} label The label we want to create segments out of.
    * @param {Range} range The indexes which define how to create the segments.
    * @param {number=} [startIndex] An optional index which tells where we want to start the first segment from
@@ -19195,6 +19263,7 @@
     return segments;
   }
   /**
+   * @ignore
    * @param {string} label The label we want to create segments out of.
    * @param {Range[]} ranges The ranges defining indices for cutting the string into segments.
    * @returns {Segment[]} An array of segments, covering the entire string label.
@@ -19222,27 +19291,199 @@
     return labels;
   }
 
+  const KEYS = Object.freeze({
+    ENTER: 13,
+    ESCAPE: 27,
+    SPACE: 32,
+    TAB: 9,
+    BACKSPACE: 8,
+    DELETE: 46,
+    ALT: 18,
+    CTRL: 17,
+    SHIFT: 16,
+    ARROW_UP: 38,
+    ARROW_DOWN: 40,
+    ARROW_LEFT: 37,
+    ARROW_RIGHT: 39,
+    PAGE_DOWN: 34,
+    PAGE_UP: 33,
+    HOME: 36,
+    END: 35,
+    F10: 121,
+    A: 65,
+    F: 70,
+    ZERO: 48,
+    NINE: 57,
+    NUMPAD_ZERO: 96,
+    NUMPAD_NINE: 105,
+    SUBTRACTION: 189,
+    DECIMAL: 190,
+    NUMPAD_DECIMAL: 110,
+    isArrow: key => key === KEYS.ARROW_UP || key === KEYS.ARROW_DOWN || key === KEYS.ARROW_LEFT || key === KEYS.ARROW_RIGHT
+  });
+
+  function getFieldKeyboardNavigation(_ref) {
+    let {
+      select,
+      confirm,
+      cancel
+    } = _ref;
+
+    const getElement = function (elm) {
+      let next = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      const parentElm = elm && elm.parentElement[next ? 'nextElementSibling' : 'previousElementSibling'];
+      return parentElm && parentElm.querySelector('[role]');
+    };
+
+    let startedRange = false;
+
+    const setStartedRange = val => {
+      startedRange = val;
+    };
+
+    const handleKeyDown = event => {
+      let elementToFocus;
+      const {
+        keyCode,
+        shiftKey = false
+      } = event.nativeEvent;
+
+      switch (keyCode) {
+        case KEYS.SHIFT:
+          // This is to ensure we include the first value when starting a range selection.
+          setStartedRange(true);
+          break;
+
+        case KEYS.SPACE:
+          select([+event.currentTarget.getAttribute('data-n')]);
+          break;
+
+        case KEYS.ARROW_DOWN:
+        case KEYS.ARROW_RIGHT:
+          elementToFocus = getElement(event.currentTarget, true);
+
+          if (shiftKey && elementToFocus) {
+            if (startedRange) {
+              select([+event.currentTarget.getAttribute('data-n')], true);
+              setStartedRange(false);
+            }
+
+            select([+elementToFocus.getAttribute('data-n')], true);
+          }
+
+          break;
+
+        case KEYS.ARROW_UP:
+        case KEYS.ARROW_LEFT:
+          elementToFocus = getElement(event.currentTarget, false);
+
+          if (shiftKey && elementToFocus) {
+            if (startedRange) {
+              select([+event.currentTarget.getAttribute('data-n')], true);
+              setStartedRange(false);
+            }
+
+            select([+elementToFocus.getAttribute('data-n')], true);
+          }
+
+          break;
+
+        case KEYS.ENTER:
+          confirm();
+          break;
+
+        case KEYS.ESCAPE:
+          cancel();
+          return;
+        // let it propagate to top-level
+
+        default:
+          return;
+        // don't stop propagation since we want to outsource keydown to other handlers.
+      }
+
+      if (elementToFocus) {
+        elementToFocus.focus();
+      }
+
+      event.preventDefault();
+      event.stopPropagation();
+    };
+
+    return handleKeyDown;
+  }
+  function getListboxInlineKeyboardNavigation(_ref2) {
+    let {
+      setKeyboardActive
+    } = _ref2;
+
+    const focusInsideListbox = element => {
+      const fieldElement = element.querySelector('.search input, .value.selector, .value');
+      setKeyboardActive(true);
+
+      if (fieldElement) {
+        fieldElement.focus();
+      }
+    };
+
+    const focusContainer = element => {
+      setKeyboardActive(false);
+      element.focus();
+    };
+
+    const handleKeyDown = event => {
+      const {
+        keyCode
+      } = event.nativeEvent;
+
+      switch (keyCode) {
+        // case KEYS.TAB: TODO: Focus confirm button using keyboard.focusSelection when we can access the useKeyboard hook.
+        case KEYS.ENTER:
+        case KEYS.SPACE:
+          focusInsideListbox(event.currentTarget);
+          break;
+
+        case KEYS.ESCAPE:
+          focusContainer(event.currentTarget);
+          break;
+
+        default:
+          return;
+      } // Note: We should not stop propagation here as it will block the containing app
+      // from handling keydown events.
+
+
+      event.preventDefault();
+    };
+
+    return handleKeyDown;
+  }
+
   const ellipsis = {
     width: '100%',
     overflow: 'hidden',
     textOverflow: 'ellipsis'
   };
-  const useStyles$a = makeStyles$1(theme => ({
+  const barPadPx = 4;
+  const barBorderWidthPx = 1;
+  const barWithCheckboxLeftPadEm = 2;
+  const frequencyTextNone = '0';
+  const useStyles$b = makeStyles$1(theme => ({
     row: {
       flexWrap: 'nowrap',
       borderBottom: "1px solid ".concat(theme.palette.divider),
-      color: theme.palette.text.primary,
-      '&:focus': {
-        boxShadow: "inset 0 0 0 2px ".concat(theme.palette.custom.focusOutline),
-        outline: 'none'
-      }
+      color: theme.palette.text.primary
     },
     column: {
       flexWrap: 'nowrap',
       borderRight: "1px solid ".concat(theme.palette.divider),
-      color: theme.palette.text.primary,
+      color: theme.palette.text.primary
+    },
+    fieldRoot: {
       '&:focus': {
-        boxShadow: "inset 0 0 0 2px ".concat(theme.palette.custom.focusOutline),
+        boxShadow: "inset 0 0 0 2px ".concat(theme.palette.custom.focusBorder, " !important")
+      },
+      '&:focus-visible': {
         outline: 'none'
       }
     },
@@ -19281,7 +19522,11 @@
       margin: 0,
       width: '100%',
       // For checkboxes the first child is the checkbox container, second is the label container.
-      '& > span:nth-child(2)': _objectSpread2({}, ellipsis)
+      '& > span:nth-child(2)': _objectSpread2(_objectSpread2({}, ellipsis), {}, {
+        display: 'flex',
+        alignItems: 'center',
+        paddingLeft: '8px'
+      })
     },
     // The icons container holding tick and lock, shown inside fields.
     icon: {
@@ -19304,6 +19549,38 @@
     X: {
       background: theme.palette.selected.excluded,
       color: theme.palette.selected.excludedContrastText
+    },
+    frequencyCount: {
+      paddingLeft: '8px',
+      paddingRight: '8px'
+    },
+    barContainer: {
+      position: 'relative'
+    },
+    bar: {
+      border: "".concat(barBorderWidthPx, "px solid"),
+      borderColor: '#D9D9D9',
+      height: '1em',
+      position: 'absolute',
+      zIndex: '-1',
+      alignSelf: 'center',
+      left: "".concat(barPadPx, "px"),
+      transition: 'width 0.2s'
+    },
+    barSelected: {
+      opacity: '30%',
+      zIndex: '0',
+      background: theme.palette.background.lighter
+    },
+    barWithCheckbox: {
+      left: "".concat(barWithCheckboxLeftPadEm, "em")
+    },
+    barSelectedWithCheckbox: {
+      background: '#BFE5D0',
+      borderColor: '#BFE5D0'
+    },
+    excludedTextWithCheckbox: {
+      color: '#828282'
     }
   }));
   function RowColumn(_ref) {
@@ -19321,11 +19598,17 @@
       pages,
       isLocked,
       checkboxes = false,
-      dense = false
+      dense = false,
+      frequencyMode = 'N',
+      actions,
+      frequencyMax = '',
+      histogram = false,
+      keyboard
     } = data;
+    const handleKeyDownCallback = react.exports.useCallback(getFieldKeyboardNavigation(actions), [actions]);
     const [isSelected, setSelected] = react.exports.useState(false);
     const [cell, setCell] = react.exports.useState();
-    const classes = useStyles$a();
+    const classes = useStyles$b();
     const [classArr, setClassArr] = react.exports.useState([]);
     react.exports.useEffect(() => {
       if (!pages) {
@@ -19345,6 +19628,11 @@
 
       setCell(c);
     }, [pages]);
+
+    const isExcluded = c => c ? c.qState === 'X' || c.qState === 'XS' || c.qState === 'XL' : null;
+
+    const isAlternative = c => c ? c.qState === 'A' : null;
+
     react.exports.useEffect(() => {
       if (!cell) {
         return;
@@ -19357,9 +19645,9 @@
       if (!checkboxes) {
         if (cell.qState === 'S' || cell.qState === 'L') {
           clazzArr.push(classes.S);
-        } else if (cell.qState === 'A') {
+        } else if (isAlternative(cell)) {
           clazzArr.push(classes.A);
-        } else if (cell.qState === 'X' || cell.qState === 'XS' || cell.qState === 'XL') {
+        } else if (isExcluded(cell)) {
           clazzArr.push(classes.X);
         }
       }
@@ -19367,6 +19655,10 @@
       setClassArr(clazzArr);
     }, [cell && cell.qState]);
 
+    const joinClassNames = namesArray => namesArray.filter(c => !!c).join(' ').trim();
+
+    const hasGrayText = () => (isAlternative(cell) || isExcluded(cell)) && checkboxes ? classes.excludedTextWithCheckbox : false;
+
     const getValueField = _ref2 => {
       let {
         lbl,
@@ -19378,7 +19670,7 @@
         component: "span",
         variant: "body2",
         key: ix,
-        className: [classes.labelText, highlighted && classes.highlighted, dense && classes.labelDense].filter(c => !!c).join(' ').trim(),
+        className: joinClassNames([classes.labelText, highlighted && classes.highlighted, dense && classes.labelDense, hasGrayText()]),
         color: color
       }, /*#__PURE__*/React.createElement("span", {
         style: {
@@ -19412,7 +19704,16 @@
       });
     };
 
-    const label = cell ? cell.qText : ''; // Search highlights. Split up labelText span into several and add the highlighted class to matching sub-strings.
+    const label = cell ? cell.qText : '';
+
+    const getFrequencyText = () => {
+      if (cell) {
+        return cell.qFrequency ? cell.qFrequency : frequencyTextNone;
+      }
+
+      return '';
+    }; // Search highlights. Split up labelText span into several and add the highlighted class to matching sub-strings.
+
 
     const ranges = cell && cell.qHighlightRanges && cell.qHighlightRanges.qRanges.sort((a, b) => a.qCharPos - b.qCharPos) || [];
     const labels = getSegmentsFromRanges(label, ranges);
@@ -19448,19 +19749,43 @@
       flexGrow: 1,
       padding: checkboxes ? 0 : undefined
     };
-    return /*#__PURE__*/React.createElement(Grid$1, {
+
+    const hasHistogramBar = () => cell && histogram && getFrequencyText() !== frequencyTextNone;
+
+    const getBarWidth = qFrequency => {
+      const freqStr = String(qFrequency);
+      const isPercent = freqStr.substring(freqStr.length - 1) === '%';
+      const freq = parseFloat(isPercent ? freqStr : qFrequency);
+      const rightSlice = checkboxes ? "(".concat(barWithCheckboxLeftPadEm, "em + ").concat(barPadPx + barBorderWidthPx * 2, "px)") : "".concat(barPadPx * 2 + barBorderWidthPx * 2, "px");
+      const width = isPercent ? freq : freq / frequencyMax * 100;
+      return "calc(".concat(width, "% - ").concat(rightSlice, ")");
+    };
+
+    const isFirstElement = index === 0;
+    return /*#__PURE__*/React.createElement("div", {
+      className: classes.barContainer
+    }, /*#__PURE__*/React.createElement(Grid$1, {
       container: true,
       spacing: 0,
-      className: ['value', ...classArr].join(' ').trim(),
+      className: joinClassNames(['value', ...classArr]),
+      classes: {
+        root: classes.fieldRoot
+      },
       style: style,
       onClick: onClick,
       onMouseDown: onMouseDown,
       onMouseUp: onMouseUp,
       onMouseEnter: onMouseEnter,
+      onKeyDown: handleKeyDownCallback,
       role: column ? 'column' : 'row',
-      tabIndex: 0,
+      tabIndex: isFirstElement && (!keyboard.enabled || keyboard.active) ? 0 : -1,
       "data-n": cell && cell.qElemNumber
-    }, /*#__PURE__*/React.createElement(Grid$1, {
+    }, hasHistogramBar() && /*#__PURE__*/React.createElement("div", {
+      className: joinClassNames([classes.bar, checkboxes && classes.barWithCheckbox, isSelected && (checkboxes ? classes.barSelectedWithCheckbox : classes.barSelected)]),
+      style: {
+        width: getBarWidth(cell.qFrequency)
+      }
+    }), /*#__PURE__*/React.createElement(Grid$1, {
       item: true,
       style: cellStyle,
       className: classes.cell,
@@ -19470,7 +19795,19 @@
       color: 'inherit'
     }) : getFieldWithRanges({
       lbls: labels
-    })), (showLock || showTick) && /*#__PURE__*/React.createElement(Grid$1, {
+    })), frequencyMode !== 'N' && /*#__PURE__*/React.createElement(Grid$1, {
+      item: true,
+      style: {
+        display: 'flex',
+        alignItems: 'center'
+      },
+      className: classes.frequencyCount
+    }, /*#__PURE__*/React.createElement(Typography$1, {
+      noWrap: true,
+      color: "inherit",
+      variant: "body2",
+      className: joinClassNames([dense && classes.labelDense, classes.labelText, hasGrayText()])
+    }, getFrequencyText())), (showLock || showTick) && /*#__PURE__*/React.createElement(Grid$1, {
       item: true,
       className: classes.icon
     }, showLock && /*#__PURE__*/React.createElement(Lock, {
@@ -19479,7 +19816,7 @@
     }), showTick && /*#__PURE__*/React.createElement(Tick, {
       style: iconStyles,
       size: "small"
-    })));
+    }))));
   }
 
   function getSizeInfo(_ref) {
@@ -19511,23 +19848,29 @@
       height,
       width,
       listLayout = 'vertical',
+      frequencyMode = 'N',
+      histogram = false,
       rangeSelect = true,
       checkboxes = false,
       update = undefined,
-      dense = false
+      dense = false,
+      keyboard = {},
+      selectDisabled = () => false
     } = _ref2;
     const [layout] = useLayout$1(model);
     const [pages, setPages] = react.exports.useState(null);
     const [isLoadingData, setIsLoadingData] = react.exports.useState(false);
     const {
       instantPages = [],
-      interactionEvents
+      interactionEvents,
+      select
     } = useSelectionsInteractions({
       layout,
       selections,
       pages,
       rangeSelect,
       checkboxes,
+      selectDisabled,
       doc: document
     });
     const loaderRef = react.exports.useRef(null);
@@ -19629,6 +19972,9 @@
       height
     });
     const isLocked = layout && layout.qListObject.qDimensionInfo.qLocked;
+    const {
+      frequencyMax
+    } = layout;
     return /*#__PURE__*/React.createElement(InfiniteLoader, {
       isItemLoaded: isItemLoaded,
       itemCount: count,
@@ -19655,9 +20001,18 @@
           isLocked,
           column: !isVertical,
           pages
-        }, isLocked ? {} : interactionEvents), {}, {
+        }, isLocked || selectDisabled() ? {} : interactionEvents), {}, {
           checkboxes,
-          dense
+          dense,
+          frequencyMode,
+          actions: {
+            select,
+            confirm: () => selections && selections.confirm.call(selections),
+            cancel: () => selections && selections.cancel.call(selections)
+          },
+          frequencyMax,
+          histogram,
+          keyboard
         }),
         itemSize: itemSize,
         onItemsRendered: onItemsRendered,
@@ -19893,13 +20248,13 @@
     }];
   }
 
-  const useStyles$9 = makeStyles(theme => ({
+  const useStyles$a = makeStyles(theme => ({
     icon: {
       color: theme.palette.text.primary
     }
   }));
 
-  const MoreItem = _ref => {
+  function MoreItem(_ref) {
     let {
       item,
       onActionClick = () => {}
@@ -19911,7 +20266,7 @@
     } = useActionState(item);
     const {
       icon
-    } = useStyles$9();
+    } = useStyles$a();
 
     const handleClick = () => {
       item.action();
@@ -19927,7 +20282,7 @@
     }, SvgIcon(item.getSvgIconShape())), /*#__PURE__*/React.createElement(Typography$1, {
       noWrap: true
     }, item.label)) : null;
-  };
+  }
 
   const More$1 = React.forwardRef((_ref2, ref) => {
     let {
@@ -19987,7 +20342,7 @@
     /** @type {'njs-action-toolbar-popover'} */
     className: 'njs-action-toolbar-popover'
   };
-  const useStyles$8 = makeStyles(theme => ({
+  const useStyles$9 = makeStyles(theme => ({
     itemSpacing: {
       padding: theme.spacing(0, 0.5)
     },
@@ -20009,7 +20364,7 @@
       itemSpacing,
       firstItemSpacing,
       lastItemSpacing
-    } = useStyles$8();
+    } = useStyles$9();
     return actions.length > 0 ? /*#__PURE__*/React.createElement(Grid$1, {
       item: true,
       container: true,
@@ -20056,7 +20411,7 @@
     horizontal: 'right'
   };
 
-  const ActionsToolbar = _ref2 => {
+  function ActionsToolbar(_ref2) {
     let {
       show = true,
       actions = [],
@@ -20085,7 +20440,7 @@
     const defaultSelectionActions = useDefaultSelectionActions(selections);
     const {
       itemSpacing
-    } = useStyles$8();
+    } = useStyles$9();
     const {
       translator,
       keyboardNavigation
@@ -20218,7 +20573,7 @@
         }
       }
     }, Actions) : show && Actions;
-  };
+  }
 
   const search = props => _objectSpread2(_objectSpread2({}, props), {}, {
     shapes: [{
@@ -20229,13 +20584,19 @@
     }]
   });
 
-  var Search = (props => SvgIcon(search(props)));
+  var SearchIcon = (props => SvgIcon(search(props)));
 
-  const useStyles$7 = makeStyles$1(theme => ({
+  const useStyles$8 = makeStyles$1(theme => ({
     root: {
+      border: 'none',
+      borderRadius: 0,
       '& fieldset': {
-        borderRadius: 0,
-        borderColor: "".concat(theme.palette.divider, " transparent")
+        border: "1px solid ".concat(theme.palette.divider),
+        borderWidth: '1px 0 1px 0',
+        borderRadius: 0
+      },
+      '&:hover': {
+        border: 'none'
       }
     },
     dense: {
@@ -20251,6 +20612,7 @@
   function ListBoxSearch(_ref) {
     let {
       model,
+      keyboard,
       autoFocus = true,
       dense = false
     } = _ref;
@@ -20277,11 +20639,11 @@
       }
     };
 
-    const classes = useStyles$7();
+    const classes = useStyles$8();
     return /*#__PURE__*/React.createElement(OutlinedInput$1, {
       startAdornment: /*#__PURE__*/React.createElement(InputAdornment$1, {
         position: "start"
-      }, /*#__PURE__*/React.createElement(Search, {
+      }, /*#__PURE__*/React.createElement(SearchIcon, {
         size: dense ? 'small' : 'normal'
       })),
       className: ['search', classes.root, dense && classes.dense].filter(Boolean).join(' '),
@@ -20291,7 +20653,10 @@
       placeholder: translator.get('Listbox.Search'),
       value: value,
       onChange: onChange,
-      onKeyDown: onKeyDown
+      onKeyDown: onKeyDown,
+      inputProps: {
+        tabIndex: !keyboard.enabled || keyboard.active ? 0 : -1
+      }
     });
   }
 
@@ -20613,10 +20978,14 @@
     }, isLocked ? /*#__PURE__*/React.createElement(IconButton$1, {
       onClick: unlock,
       disabled: !isLocked
-    }, /*#__PURE__*/React.createElement(Lock, null)) : /*#__PURE__*/React.createElement(IconButton$1, {
+    }, /*#__PURE__*/React.createElement(Lock, {
+      title: translator.get('Listbox.Unlock')
+    })) : /*#__PURE__*/React.createElement(IconButton$1, {
       onClick: lock,
       disabled: !hasSelections
-    }, /*#__PURE__*/React.createElement(Unlock, null))), /*#__PURE__*/React.createElement(Grid$1, {
+    }, /*#__PURE__*/React.createElement(Unlock, {
+      title: translator.get('Listbox.Lock')
+    }))), /*#__PURE__*/React.createElement(Grid$1, {
       item: true,
       xs: true
     }), /*#__PURE__*/React.createElement(Grid$1, {
@@ -20654,7 +21023,7 @@
     }))));
   }
 
-  const useStyles$6 = makeStyles$1(theme => ({
+  const useStyles$7 = makeStyles$1(theme => ({
     item: {
       backgroundColor: theme.palette.background.paper,
       position: 'relative',
@@ -20680,7 +21049,7 @@
     const alignTo = moreAlignTo || react.exports.useRef();
     const theme = useTheme$2();
     const [showListBoxPopover, setShowListBoxPopover] = react.exports.useState(false);
-    const classes = useStyles$6();
+    const classes = useStyles$7();
 
     const handleShowListBoxPopover = e => {
       if (e.currentTarget.contains(e.target)) {
@@ -20837,7 +21206,7 @@
 
   var DownArrow = (props => SvgIcon(downArrow(props)));
 
-  const useStyles$5 = makeStyles$1(theme => ({
+  const useStyles$6 = makeStyles$1(theme => ({
     item: {
       backgroundColor: theme.palette.background.paper,
       position: 'relative',
@@ -20860,7 +21229,7 @@
       moreAlignTo = null,
       onClose = () => {}
     } = _ref;
-    const classes = useStyles$5(); // If originated from the `more` item show fields directly
+    const classes = useStyles$6(); // If originated from the `more` item show fields directly
 
     const [showFields, setShowFields] = react.exports.useState(!!moreAlignTo);
     const [showStateIx, setShowStateIx] = react.exports.useState(-1); // If originated from the `more` item align it
@@ -21000,7 +21369,7 @@
     }) : Component;
   }
 
-  const useStyles$4 = makeStyles$1(theme => ({
+  const useStyles$5 = makeStyles$1(theme => ({
     item: {
       backgroundColor: theme.palette.background.paper,
       position: 'relative',
@@ -21021,7 +21390,7 @@
       items = [],
       api
     } = _ref;
-    const classes = useStyles$4();
+    const classes = useStyles$5();
     const theme = useTheme$2();
     const [showMoreItems, setShowMoreItems] = react.exports.useState(false);
     const [showItemIx, setShowItemIx] = react.exports.useState(-1);
@@ -21340,7 +21709,7 @@
     }, /*#__PURE__*/React.createElement(ClearSelections, null))));
   }
 
-  const AppSelections = _ref => {
+  function AppSelections(_ref) {
     let {
       app
     } = _ref;
@@ -21374,7 +21743,7 @@
       api: appSelections,
       app: app
     })));
-  };
+  }
   function mount(_ref2) {
     let {
       element,
@@ -21868,33 +22237,26 @@
     style: {}
   };
 
-  function ListBoxPortal(_ref) {
-    let {
-      app,
-      fieldIdentifier,
-      stateName,
-      element,
-      options
-    } = _ref;
-    return ReactDOM.createPortal( /*#__PURE__*/React.createElement(ListBoxInline, {
-      app: app,
-      fieldIdentifier: fieldIdentifier,
-      stateName: stateName,
-      options: options
-    }), element);
-  }
-  function ListBoxInline(_ref2) {
+  const useStyles$4 = makeStyles$1(() => ({
+    listBoxHeader: {
+      alignSelf: 'center',
+      display: 'inline-flex'
+    }
+  }));
+  function ListBoxInline(_ref) {
     let {
       app,
       fieldIdentifier,
       stateName = '$',
-      options = {}
-    } = _ref2;
+      options = {},
+      fieldDef
+    } = _ref;
     const {
       title,
       direction,
       listLayout,
       search = true,
+      focusSearch = false,
       toolbar = true,
       rangeSelect = true,
       checkboxes = false,
@@ -21902,9 +22264,43 @@
       sessionModel = undefined,
       selectionsApi = undefined,
       update = undefined,
-      dense = false
+      dense = false,
+      selectDisabled = () => false
+    } = options;
+    let {
+      frequencyMode,
+      histogram = false
     } = options;
 
+    if (fieldDef && fieldDef.failedToFetchFieldDef) {
+      histogram = false;
+      frequencyMode = 'N';
+    }
+
+    switch (true) {
+      case ['none', 'N', 'NX_FREQUENCY_NONE'].includes(frequencyMode):
+        frequencyMode = 'N';
+        break;
+
+      case ['value', 'V', 'NX_FREQUENCY_VALUE', 'default'].includes(frequencyMode):
+        frequencyMode = 'V';
+        break;
+
+      case ['percent', 'P', 'NX_FREQUENCY_PERCENT'].includes(frequencyMode):
+        frequencyMode = 'P';
+        break;
+
+      case ['relative', 'R', 'NX_FREQUENCY_RELATIVE'].includes(frequencyMode):
+        frequencyMode = 'R';
+        break;
+
+      default:
+        frequencyMode = 'N';
+        break;
+    }
+
+    const getListdefFrequencyMode = () => histogram && frequencyMode === 'N' ? 'V' : frequencyMode;
+
     const listdef = _objectSpread2({
       qInfo: {
         qType: 'njsListbox'
@@ -21912,6 +22308,7 @@
       qListObjectDef: {
         qStateName: stateName,
         qShowAlternatives: true,
+        qFrequencyMode: getListdefFrequencyMode(),
         qInitialDataFetch: [{
           qTop: 0,
           qLeft: 0,
@@ -21941,6 +22338,13 @@
       fieldName = fieldIdentifier;
     }
 
+    if (frequencyMode !== 'N' || histogram) {
+      const field = fieldIdentifier.qLibraryId ? fieldDef : fieldName;
+      listdef.frequencyMax = {
+        qValueExpression: "Max(AGGR(Count([".concat(field, "]), [").concat(field, "]))")
+      };
+    }
+
     let [model] = useSessionModel(listdef, sessionModel ? null : app, fieldName, stateName);
 
     if (sessionModel) {
@@ -21954,6 +22358,7 @@
     }
 
     const theme = useTheme$2();
+    const classes = useStyles$4();
     const lock = react.exports.useCallback(() => {
       model.lock('/qListObjectDef');
     }, [model]);
@@ -21961,11 +22366,24 @@
       model.unlock('/qListObjectDef');
     }, [model]);
     const {
-      translator
+      translator,
+      keyboardNavigation
     } = react.exports.useContext(InstanceContext);
     const moreAlignTo = react.exports.useRef();
     const [layout] = useLayout$1(model);
     const [showToolbar, setShowToolbar] = react.exports.useState(false);
+    const [showSearch, setShowSearch] = react.exports.useState(false);
+    const [autoFocusSearch, setAutoFocusSearch] = react.exports.useState(focusSearch);
+    const [keyboardActive, setKeyboardActive] = react.exports.useState(false);
+    const handleKeyDown = getListboxInlineKeyboardNavigation({
+      setKeyboardActive
+    }); // Expose the keyboard flags in the same way as the keyboard hook does.
+
+    const keyboard = {
+      enabled: keyboardNavigation,
+      // this will be static until we can access the useKeyboard hook
+      active: keyboardActive
+    };
     react.exports.useEffect(() => {
       if (selections) {
         if (!selections.isModal(model)) {
@@ -21996,32 +22414,52 @@
     }) : [];
     const counts = layout.qListObject.qDimensionInfo.qStateCounts;
     const hasSelections = counts.qSelected + counts.qSelectedExcluded + counts.qLocked + counts.qLockedExcluded > 0;
-    const minHeight = 49 + (search ? 40 : 0) + 49;
+    const searchVisible = (search === true || search === 'toggle' && showSearch) && !selectDisabled();
+    const minHeight = 49 + (searchVisible ? 40 : 0) + 49;
+
+    const onShowSearch = () => {
+      const newValue = !showSearch;
+      setShowSearch(newValue);
+      setAutoFocusSearch(newValue);
+    };
+
+    const getSearchOrUnlock = () => search === 'toggle' && !hasSelections ? /*#__PURE__*/React.createElement(IconButton$1, {
+      onClick: onShowSearch,
+      tabIndex: -1,
+      title: translator.get('Listbox.Search')
+    }, /*#__PURE__*/React.createElement(SearchIcon, null)) : /*#__PURE__*/React.createElement(IconButton$1, {
+      onClick: lock,
+      tabIndex: -1,
+      disabled: !hasSelections
+    }, /*#__PURE__*/React.createElement(Unlock, null));
+
     return /*#__PURE__*/React.createElement(Grid$1, {
       container: true,
+      tabIndex: keyboard.enabled && !keyboard.active ? 0 : -1,
       direction: "column",
       spacing: 0,
       style: {
         height: '100%',
         minHeight: "".concat(minHeight, "px")
-      }
+      },
+      onKeyDown: handleKeyDown
     }, toolbar && /*#__PURE__*/React.createElement(Grid$1, {
       item: true,
       container: true,
       style: {
-        padding: theme.spacing(1),
-        borderBottom: "1px solid ".concat(theme.palette.divider)
+        padding: theme.spacing(1)
       }
     }, /*#__PURE__*/React.createElement(Grid$1, {
       item: true
     }, isLocked ? /*#__PURE__*/React.createElement(IconButton$1, {
+      tabIndex: -1,
       onClick: unlock,
       disabled: !isLocked
-    }, /*#__PURE__*/React.createElement(Lock, null)) : /*#__PURE__*/React.createElement(IconButton$1, {
-      onClick: lock,
-      disabled: !hasSelections
-    }, /*#__PURE__*/React.createElement(Unlock, null))), /*#__PURE__*/React.createElement(Grid$1, {
-      item: true
+    }, /*#__PURE__*/React.createElement(Lock, {
+      title: translator.get('Listbox.Unlock')
+    })) : getSearchOrUnlock()), /*#__PURE__*/React.createElement(Grid$1, {
+      item: true,
+      className: classes.listBoxHeader
     }, /*#__PURE__*/React.createElement(Typography$1, {
       variant: "h6",
       noWrap: true
@@ -22049,37 +22487,103 @@
         onConfirm: () => {},
         onCancel: () => {}
       }
-    }))), search ? /*#__PURE__*/React.createElement(Grid$1, {
+    }))), searchVisible && /*#__PURE__*/React.createElement(Grid$1, {
       item: true
     }, /*#__PURE__*/React.createElement(ListBoxSearch, {
       model: model,
-      autoFocus: false,
-      dense: dense
-    })) : '', /*#__PURE__*/React.createElement(Grid$1, {
+      autoFocus: autoFocusSearch,
+      dense: dense,
+      keyboard: keyboard
+    })), /*#__PURE__*/React.createElement(Grid$1, {
       item: true,
       xs: true
     }, /*#__PURE__*/React.createElement("div", {
       ref: moreAlignTo
-    }), /*#__PURE__*/React.createElement(AutoSizer, null, _ref3 => {
+    }), /*#__PURE__*/React.createElement(AutoSizer, null, _ref2 => {
       let {
         height,
         width
-      } = _ref3;
+      } = _ref2;
       return /*#__PURE__*/React.createElement(ListBox, {
         model: model,
         selections: selections,
         direction: direction,
         listLayout: listLayout,
+        frequencyMode: frequencyMode,
+        histogram: histogram,
         rangeSelect: rangeSelect,
         checkboxes: checkboxes,
         height: height,
         width: width,
         update: update,
-        dense: dense
+        dense: dense,
+        selectDisabled: selectDisabled,
+        keyboard: keyboard
       });
     })));
   }
 
+  function ListBoxFetchMasterItem(_ref) {
+    let {
+      app,
+      fieldIdentifier,
+      stateName = '$',
+      options = {}
+    } = _ref;
+    const [fieldDef, setFieldDef] = react.exports.useState('');
+    const [isFetchingData, setIsFetchingData] = react.exports.useState(false);
+    react.exports.useEffect(() => {
+      async function fetchData() {
+        setIsFetchingData(true);
+
+        try {
+          const dim = await app.getDimension(fieldIdentifier.qLibraryId);
+          const dimLayout = await dim.getLayout();
+          setFieldDef(dimLayout.qDim.qFieldDefs ? dimLayout.qDim.qFieldDefs[0] : '');
+          setIsFetchingData(false);
+        } catch (e) {
+          setIsFetchingData(false);
+          setFieldDef({
+            failedToFetchFieldDef: true
+          });
+          throw new Error("Disabling frequency count and histogram: ".concat(e && e.message));
+        }
+      }
+
+      fetchData();
+    }, []);
+
+    if (isFetchingData) {
+      return null;
+    }
+
+    return /*#__PURE__*/React.createElement(ListBoxInline, {
+      app: app,
+      fieldIdentifier: fieldIdentifier,
+      stateName: stateName,
+      options: options,
+      fieldDef: fieldDef
+    });
+  }
+  function ListBoxPortal(_ref2) {
+    let {
+      app,
+      fieldIdentifier,
+      stateName,
+      element,
+      options
+    } = _ref2;
+    const isFrequencyMaxNeeded = options.histogram || options.frequencyMode !== 'N';
+    const TheComponent = fieldIdentifier.qLibraryId && isFrequencyMaxNeeded ? ListBoxFetchMasterItem : ListBoxInline;
+    return ReactDOM.createPortal( /*#__PURE__*/React.createElement(TheComponent, {
+      app: app,
+      fieldIdentifier: fieldIdentifier,
+      stateName: stateName,
+      element: element,
+      options: options
+    }), element);
+  }
+
   const idGen = [[10, 31], [0, 31], [0, 31], [0, 31], [0, 31], [0, 31]];
 
   function toChar(_ref) {
@@ -23255,7 +23759,7 @@
 
   /* eslint-disable react/no-array-index-key */
 
-  const DescriptionRow = _ref => {
+  function DescriptionRow(_ref) {
     let {
       d
     } = _ref;
@@ -23312,9 +23816,9 @@
         fontWeight: 400
       }
     }, d.label))));
-  };
+  }
 
-  const Descriptions = _ref2 => {
+  function Descriptions(_ref2) {
     let {
       data
     } = _ref2;
@@ -23347,7 +23851,7 @@
         color: "textSecondary"
       }, e.title), Rows);
     }));
-  };
+  }
 
   function Error$1(_ref3) {
     let {
@@ -23452,7 +23956,7 @@
       }
     }
   }));
-  const Cancel = _ref => {
+  function Cancel(_ref) {
     let {
       cancel,
       translator
@@ -23478,8 +23982,8 @@
       variant: "contained",
       onClick: cancel
     }, translator.get('Cancel'))));
-  };
-  const Retry = _ref2 => {
+  }
+  function Retry(_ref2) {
     let {
       retry,
       translator
@@ -23503,7 +24007,7 @@
       variant: "contained",
       onClick: retry
     }, props), translator.get('Retry'))));
-  };
+  }
   function LongRunningQuery(_ref3) {
     let {
       canCancel,
@@ -23597,7 +24101,7 @@
     }
   }));
 
-  const Header = _ref => {
+  function Header(_ref) {
     let {
       layout,
       sn,
@@ -23674,7 +24178,7 @@
     }, layout.subtitle))), /*#__PURE__*/React.createElement(Grid$1, {
       item: true
     }, Toolbar));
-  };
+  }
 
   /**
    * @interface
@@ -23693,7 +24197,7 @@
     }
   }));
 
-  const Footer = _ref => {
+  function Footer(_ref) {
     let {
       layout
     } = _ref;
@@ -23710,7 +24214,7 @@
       variant: "body2",
       className: CellFooter.className
     }, layout.footnote))) : null;
-  };
+  }
 
   class RenderDebouncer {
     constructor() {
@@ -23780,7 +24284,7 @@
     className: 'njs-viz'
   };
 
-  const Supernova = _ref => {
+  function Supernova(_ref) {
     let {
       sn,
       snOptions: options,
@@ -23900,7 +24404,7 @@
         height: '100%'
       }
     }));
-  };
+  }
 
   /**
    * @interface
@@ -23978,7 +24482,7 @@
     }
   };
 
-  const LoadingSn = _ref => {
+  function LoadingSn(_ref) {
     let {
       delay = 750
     } = _ref;
@@ -23988,7 +24492,7 @@
       return () => clearTimeout(handle);
     }, []);
     return showLoading ? /*#__PURE__*/React.createElement(Loading, null) : null;
-  };
+  }
 
   const handleModal = _ref2 => {
     let {
@@ -24563,7 +25067,8 @@
     }
 
     return a === b;
-  }
+  } // eslint-disable-next-line default-param-last
+
 
   function getPatches() {
     let path = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '/';
@@ -25435,7 +25940,7 @@
   /* eslint no-console: 0 */
 
   /* eslint no-use-before-define: 0 */
-  // Hooks implementation heavily inspired by prect hooks
+  // Hooks implementation heavily inspired by preact hooks
   let currentComponent;
   let currentIndex;
 
@@ -27245,1556 +27750,1603 @@
   var semver = {exports: {}};
 
   (function (module, exports) {
-    exports = module.exports = SemVer;
-    var debug;
-    /* istanbul ignore next */
-
-    if (typeof process === 'object' && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
-      debug = function () {
-        var args = Array.prototype.slice.call(arguments, 0);
-        args.unshift('SEMVER');
-        console.log.apply(console, args);
-      };
-    } else {
-      debug = function () {};
-    } // Note: this is the semver.org version of the spec that it implements
-    // Not necessarily the package version of this code.
-
-
-    exports.SEMVER_SPEC_VERSION = '2.0.0';
-    var MAX_LENGTH = 256;
-    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
-    /* istanbul ignore next */
-    9007199254740991; // Max safe segment length for coercion.
-
-    var MAX_SAFE_COMPONENT_LENGTH = 16; // The actual regexps go on exports.re
-
-    var re = exports.re = [];
-    var src = exports.src = [];
-    var t = exports.tokens = {};
-    var R = 0;
-
-    function tok(n) {
-      t[n] = R++;
-    } // 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.
-
-
-    tok('NUMERICIDENTIFIER');
-    src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*';
-    tok('NUMERICIDENTIFIERLOOSE');
-    src[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+'; // ## Non-numeric Identifier
-    // Zero or more digits, followed by a letter or hyphen, and then zero or
-    // more letters, digits, or hyphens.
-
-    tok('NONNUMERICIDENTIFIER');
-    src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*'; // ## Main Version
-    // Three dot-separated numeric identifiers.
-
-    tok('MAINVERSION');
-    src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + '(' + src[t.NUMERICIDENTIFIER] + ')\\.' + '(' + src[t.NUMERICIDENTIFIER] + ')';
-    tok('MAINVERSIONLOOSE');
-    src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' + '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')'; // ## Pre-release Version Identifier
-    // A numeric identifier, or a non-numeric identifier.
-
-    tok('PRERELEASEIDENTIFIER');
-    src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] + '|' + src[t.NONNUMERICIDENTIFIER] + ')';
-    tok('PRERELEASEIDENTIFIERLOOSE');
-    src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] + '|' + src[t.NONNUMERICIDENTIFIER] + ')'; // ## Pre-release Version
-    // Hyphen, followed by one or more dot-separated pre-release version
-    // identifiers.
-
-    tok('PRERELEASE');
-    src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] + '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))';
-    tok('PRERELEASELOOSE');
-    src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] + '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))'; // ## Build Metadata Identifier
-    // Any combination of digits, letters, or hyphens.
-
-    tok('BUILDIDENTIFIER');
-    src[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+'; // ## Build Metadata
-    // Plus sign, followed by one or more period-separated build metadata
-    // identifiers.
-
-    tok('BUILD');
-    src[t.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.
-
-    tok('FULL');
-    tok('FULLPLAIN');
-    src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] + src[t.PRERELEASE] + '?' + src[t.BUILD] + '?';
-    src[t.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.
-
-    tok('LOOSEPLAIN');
-    src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] + src[t.PRERELEASELOOSE] + '?' + src[t.BUILD] + '?';
-    tok('LOOSE');
-    src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$';
-    tok('GTLT');
-    src[t.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.
-
-    tok('XRANGEIDENTIFIERLOOSE');
-    src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*';
-    tok('XRANGEIDENTIFIER');
-    src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*';
-    tok('XRANGEPLAIN');
-    src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' + '(?:' + src[t.PRERELEASE] + ')?' + src[t.BUILD] + '?' + ')?)?';
-    tok('XRANGEPLAINLOOSE');
-    src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' + '(?:' + src[t.PRERELEASELOOSE] + ')?' + src[t.BUILD] + '?' + ')?)?';
-    tok('XRANGE');
-    src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$';
-    tok('XRANGELOOSE');
-    src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$'; // Coercion.
-    // Extract anything that could conceivably be a part of a valid semver
-
-    tok('COERCE');
-    src[t.COERCE] = '(^|[^\\d])' + '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' + '(?:$|[^\\d])';
-    tok('COERCERTL');
-    re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g'); // Tilde ranges.
-    // Meaning is "reasonably at or greater than"
-
-    tok('LONETILDE');
-    src[t.LONETILDE] = '(?:~>?)';
-    tok('TILDETRIM');
-    src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+';
-    re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g');
-    var tildeTrimReplace = '$1~';
-    tok('TILDE');
-    src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$';
-    tok('TILDELOOSE');
-    src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$'; // Caret ranges.
-    // Meaning is "at least and backwards compatible with"
-
-    tok('LONECARET');
-    src[t.LONECARET] = '(?:\\^)';
-    tok('CARETTRIM');
-    src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+';
-    re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g');
-    var caretTrimReplace = '$1^';
-    tok('CARET');
-    src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$';
-    tok('CARETLOOSE');
-    src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$'; // A simple gt/lt/eq thing, or just "" to indicate "any version"
-
-    tok('COMPARATORLOOSE');
-    src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$';
-    tok('COMPARATOR');
-    src[t.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`
-
-    tok('COMPARATORTRIM');
-    src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')'; // this one has to use the /g flag
-
-    re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g');
-    var 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.
-
-    tok('HYPHENRANGE');
-    src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' + '\\s+-\\s+' + '(' + src[t.XRANGEPLAIN] + ')' + '\\s*$';
-    tok('HYPHENRANGELOOSE');
-    src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' + '\\s+-\\s+' + '(' + src[t.XRANGEPLAINLOOSE] + ')' + '\\s*$'; // Star ranges basically just allow anything at all.
-
-    tok('STAR');
-    src[t.STAR] = '(<|>)?=?\\s*\\*'; // Compile to actual regexp objects.
-    // All are flag-free, unless they were created above with a flag.
-
-    for (var i = 0; i < R; i++) {
-      debug(i, src[i]);
-
-      if (!re[i]) {
-        re[i] = new RegExp(src[i]);
-      }
-    }
-
-    exports.parse = parse;
-
-    function parse(version, options) {
-      if (!options || typeof options !== 'object') {
-        options = {
-          loose: !!options,
-          includePrerelease: false
-        };
-      }
+  exports = module.exports = SemVer;
+
+  var debug;
+  /* istanbul ignore next */
+  if (typeof process === 'object' &&
+      process.env &&
+      process.env.NODE_DEBUG &&
+      /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
+    debug = function () {
+      var args = Array.prototype.slice.call(arguments, 0);
+      args.unshift('SEMVER');
+      console.log.apply(console, args);
+    };
+  } else {
+    debug = function () {};
+  }
 
-      if (version instanceof SemVer) {
-        return version;
-      }
+  // Note: this is the semver.org version of the spec that it implements
+  // Not necessarily the package version of this code.
+  exports.SEMVER_SPEC_VERSION = '2.0.0';
 
-      if (typeof version !== 'string') {
-        return null;
-      }
+  var MAX_LENGTH = 256;
+  var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
+    /* istanbul ignore next */ 9007199254740991;
 
-      if (version.length > MAX_LENGTH) {
-        return null;
-      }
+  // Max safe segment length for coercion.
+  var MAX_SAFE_COMPONENT_LENGTH = 16;
 
-      var r = options.loose ? re[t.LOOSE] : re[t.FULL];
+  // The actual regexps go on exports.re
+  var re = exports.re = [];
+  var src = exports.src = [];
+  var t = exports.tokens = {};
+  var R = 0;
 
-      if (!r.test(version)) {
-        return null;
-      }
+  function tok (n) {
+    t[n] = R++;
+  }
 
-      try {
-        return new SemVer(version, options);
-      } catch (er) {
-        return null;
-      }
+  // 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.
+
+  tok('NUMERICIDENTIFIER');
+  src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*';
+  tok('NUMERICIDENTIFIERLOOSE');
+  src[t.NUMERICIDENTIFIERLOOSE] = '[0-9]+';
+
+  // ## Non-numeric Identifier
+  // Zero or more digits, followed by a letter or hyphen, and then zero or
+  // more letters, digits, or hyphens.
+
+  tok('NONNUMERICIDENTIFIER');
+  src[t.NONNUMERICIDENTIFIER] = '\\d*[a-zA-Z-][a-zA-Z0-9-]*';
+
+  // ## Main Version
+  // Three dot-separated numeric identifiers.
+
+  tok('MAINVERSION');
+  src[t.MAINVERSION] = '(' + src[t.NUMERICIDENTIFIER] + ')\\.' +
+                     '(' + src[t.NUMERICIDENTIFIER] + ')\\.' +
+                     '(' + src[t.NUMERICIDENTIFIER] + ')';
+
+  tok('MAINVERSIONLOOSE');
+  src[t.MAINVERSIONLOOSE] = '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' +
+                          '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')\\.' +
+                          '(' + src[t.NUMERICIDENTIFIERLOOSE] + ')';
+
+  // ## Pre-release Version Identifier
+  // A numeric identifier, or a non-numeric identifier.
+
+  tok('PRERELEASEIDENTIFIER');
+  src[t.PRERELEASEIDENTIFIER] = '(?:' + src[t.NUMERICIDENTIFIER] +
+                              '|' + src[t.NONNUMERICIDENTIFIER] + ')';
+
+  tok('PRERELEASEIDENTIFIERLOOSE');
+  src[t.PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[t.NUMERICIDENTIFIERLOOSE] +
+                                   '|' + src[t.NONNUMERICIDENTIFIER] + ')';
+
+  // ## Pre-release Version
+  // Hyphen, followed by one or more dot-separated pre-release version
+  // identifiers.
+
+  tok('PRERELEASE');
+  src[t.PRERELEASE] = '(?:-(' + src[t.PRERELEASEIDENTIFIER] +
+                    '(?:\\.' + src[t.PRERELEASEIDENTIFIER] + ')*))';
+
+  tok('PRERELEASELOOSE');
+  src[t.PRERELEASELOOSE] = '(?:-?(' + src[t.PRERELEASEIDENTIFIERLOOSE] +
+                         '(?:\\.' + src[t.PRERELEASEIDENTIFIERLOOSE] + ')*))';
+
+  // ## Build Metadata Identifier
+  // Any combination of digits, letters, or hyphens.
+
+  tok('BUILDIDENTIFIER');
+  src[t.BUILDIDENTIFIER] = '[0-9A-Za-z-]+';
+
+  // ## Build Metadata
+  // Plus sign, followed by one or more period-separated build metadata
+  // identifiers.
+
+  tok('BUILD');
+  src[t.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.
+
+  tok('FULL');
+  tok('FULLPLAIN');
+  src[t.FULLPLAIN] = 'v?' + src[t.MAINVERSION] +
+                    src[t.PRERELEASE] + '?' +
+                    src[t.BUILD] + '?';
+
+  src[t.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.
+  tok('LOOSEPLAIN');
+  src[t.LOOSEPLAIN] = '[v=\\s]*' + src[t.MAINVERSIONLOOSE] +
+                    src[t.PRERELEASELOOSE] + '?' +
+                    src[t.BUILD] + '?';
+
+  tok('LOOSE');
+  src[t.LOOSE] = '^' + src[t.LOOSEPLAIN] + '$';
+
+  tok('GTLT');
+  src[t.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.
+  tok('XRANGEIDENTIFIERLOOSE');
+  src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + '|x|X|\\*';
+  tok('XRANGEIDENTIFIER');
+  src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + '|x|X|\\*';
+
+  tok('XRANGEPLAIN');
+  src[t.XRANGEPLAIN] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIER] + ')' +
+                     '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' +
+                     '(?:\\.(' + src[t.XRANGEIDENTIFIER] + ')' +
+                     '(?:' + src[t.PRERELEASE] + ')?' +
+                     src[t.BUILD] + '?' +
+                     ')?)?';
+
+  tok('XRANGEPLAINLOOSE');
+  src[t.XRANGEPLAINLOOSE] = '[v=\\s]*(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
+                          '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
+                          '(?:\\.(' + src[t.XRANGEIDENTIFIERLOOSE] + ')' +
+                          '(?:' + src[t.PRERELEASELOOSE] + ')?' +
+                          src[t.BUILD] + '?' +
+                          ')?)?';
+
+  tok('XRANGE');
+  src[t.XRANGE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAIN] + '$';
+  tok('XRANGELOOSE');
+  src[t.XRANGELOOSE] = '^' + src[t.GTLT] + '\\s*' + src[t.XRANGEPLAINLOOSE] + '$';
+
+  // Coercion.
+  // Extract anything that could conceivably be a part of a valid semver
+  tok('COERCE');
+  src[t.COERCE] = '(^|[^\\d])' +
+                '(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +
+                '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
+                '(?:\\.(\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +
+                '(?:$|[^\\d])';
+  tok('COERCERTL');
+  re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g');
+
+  // Tilde ranges.
+  // Meaning is "reasonably at or greater than"
+  tok('LONETILDE');
+  src[t.LONETILDE] = '(?:~>?)';
+
+  tok('TILDETRIM');
+  src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+';
+  re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g');
+  var tildeTrimReplace = '$1~';
+
+  tok('TILDE');
+  src[t.TILDE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAIN] + '$';
+  tok('TILDELOOSE');
+  src[t.TILDELOOSE] = '^' + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + '$';
+
+  // Caret ranges.
+  // Meaning is "at least and backwards compatible with"
+  tok('LONECARET');
+  src[t.LONECARET] = '(?:\\^)';
+
+  tok('CARETTRIM');
+  src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+';
+  re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g');
+  var caretTrimReplace = '$1^';
+
+  tok('CARET');
+  src[t.CARET] = '^' + src[t.LONECARET] + src[t.XRANGEPLAIN] + '$';
+  tok('CARETLOOSE');
+  src[t.CARETLOOSE] = '^' + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + '$';
+
+  // A simple gt/lt/eq thing, or just "" to indicate "any version"
+  tok('COMPARATORLOOSE');
+  src[t.COMPARATORLOOSE] = '^' + src[t.GTLT] + '\\s*(' + src[t.LOOSEPLAIN] + ')$|^$';
+  tok('COMPARATOR');
+  src[t.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`
+  tok('COMPARATORTRIM');
+  src[t.COMPARATORTRIM] = '(\\s*)' + src[t.GTLT] +
+                        '\\s*(' + src[t.LOOSEPLAIN] + '|' + src[t.XRANGEPLAIN] + ')';
+
+  // this one has to use the /g flag
+  re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g');
+  var 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.
+  tok('HYPHENRANGE');
+  src[t.HYPHENRANGE] = '^\\s*(' + src[t.XRANGEPLAIN] + ')' +
+                     '\\s+-\\s+' +
+                     '(' + src[t.XRANGEPLAIN] + ')' +
+                     '\\s*$';
+
+  tok('HYPHENRANGELOOSE');
+  src[t.HYPHENRANGELOOSE] = '^\\s*(' + src[t.XRANGEPLAINLOOSE] + ')' +
+                          '\\s+-\\s+' +
+                          '(' + src[t.XRANGEPLAINLOOSE] + ')' +
+                          '\\s*$';
+
+  // Star ranges basically just allow anything at all.
+  tok('STAR');
+  src[t.STAR] = '(<|>)?=?\\s*\\*';
+
+  // Compile to actual regexp objects.
+  // All are flag-free, unless they were created above with a flag.
+  for (var i = 0; i < R; i++) {
+    debug(i, src[i]);
+    if (!re[i]) {
+      re[i] = new RegExp(src[i]);
+    }
+  }
+
+  exports.parse = parse;
+  function parse (version, options) {
+    if (!options || typeof options !== 'object') {
+      options = {
+        loose: !!options,
+        includePrerelease: false
+      };
     }
 
-    exports.valid = valid;
+    if (version instanceof SemVer) {
+      return version
+    }
 
-    function valid(version, options) {
-      var v = parse(version, options);
-      return v ? v.version : null;
+    if (typeof version !== 'string') {
+      return null
     }
 
-    exports.clean = clean;
+    if (version.length > MAX_LENGTH) {
+      return null
+    }
 
-    function clean(version, options) {
-      var s = parse(version.trim().replace(/^[=v]+/, ''), options);
-      return s ? s.version : null;
+    var r = options.loose ? re[t.LOOSE] : re[t.FULL];
+    if (!r.test(version)) {
+      return null
     }
 
-    exports.SemVer = SemVer;
+    try {
+      return new SemVer(version, options)
+    } catch (er) {
+      return null
+    }
+  }
 
-    function SemVer(version, options) {
-      if (!options || typeof options !== 'object') {
-        options = {
-          loose: !!options,
-          includePrerelease: false
-        };
-      }
+  exports.valid = valid;
+  function valid (version, options) {
+    var v = parse(version, options);
+    return v ? v.version : null
+  }
 
-      if (version instanceof SemVer) {
-        if (version.loose === options.loose) {
-          return version;
-        } else {
-          version = version.version;
-        }
-      } else if (typeof version !== 'string') {
-        throw new TypeError('Invalid Version: ' + version);
-      }
+  exports.clean = clean;
+  function clean (version, options) {
+    var s = parse(version.trim().replace(/^[=v]+/, ''), options);
+    return s ? s.version : null
+  }
 
-      if (version.length > MAX_LENGTH) {
-        throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters');
-      }
+  exports.SemVer = SemVer;
 
-      if (!(this instanceof SemVer)) {
-        return new SemVer(version, options);
+  function SemVer (version, options) {
+    if (!options || typeof options !== 'object') {
+      options = {
+        loose: !!options,
+        includePrerelease: false
+      };
+    }
+    if (version instanceof SemVer) {
+      if (version.loose === options.loose) {
+        return version
+      } else {
+        version = version.version;
       }
+    } else if (typeof version !== 'string') {
+      throw new TypeError('Invalid Version: ' + version)
+    }
 
-      debug('SemVer', version, options);
-      this.options = options;
-      this.loose = !!options.loose;
-      var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+    if (version.length > MAX_LENGTH) {
+      throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')
+    }
 
-      if (!m) {
-        throw new TypeError('Invalid Version: ' + version);
-      }
+    if (!(this instanceof SemVer)) {
+      return new SemVer(version, options)
+    }
 
-      this.raw = version; // these are actually numbers
+    debug('SemVer', version, options);
+    this.options = options;
+    this.loose = !!options.loose;
 
-      this.major = +m[1];
-      this.minor = +m[2];
-      this.patch = +m[3];
+    var m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
 
-      if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
-        throw new TypeError('Invalid major version');
-      }
+    if (!m) {
+      throw new TypeError('Invalid Version: ' + version)
+    }
 
-      if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
-        throw new TypeError('Invalid minor version');
-      }
+    this.raw = version;
+
+    // these are actually numbers
+    this.major = +m[1];
+    this.minor = +m[2];
+    this.patch = +m[3];
 
-      if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
-        throw new TypeError('Invalid patch version');
-      } // numberify any prerelease numeric ids
+    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 (!m[4]) {
-        this.prerelease = [];
-      } else {
-        this.prerelease = m[4].split('.').map(function (id) {
-          if (/^[0-9]+$/.test(id)) {
-            var num = +id;
+    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+      throw new TypeError('Invalid patch version')
+    }
 
-            if (num >= 0 && num < MAX_SAFE_INTEGER) {
-              return num;
-            }
+    // numberify any prerelease numeric ids
+    if (!m[4]) {
+      this.prerelease = [];
+    } else {
+      this.prerelease = m[4].split('.').map(function (id) {
+        if (/^[0-9]+$/.test(id)) {
+          var num = +id;
+          if (num >= 0 && num < MAX_SAFE_INTEGER) {
+            return num
           }
+        }
+        return id
+      });
+    }
 
-          return id;
-        });
-      }
+    this.build = m[5] ? m[5].split('.') : [];
+    this.format();
+  }
 
-      this.build = m[5] ? m[5].split('.') : [];
-      this.format();
+  SemVer.prototype.format = function () {
+    this.version = this.major + '.' + this.minor + '.' + this.patch;
+    if (this.prerelease.length) {
+      this.version += '-' + this.prerelease.join('.');
     }
+    return this.version
+  };
 
-    SemVer.prototype.format = function () {
-      this.version = this.major + '.' + this.minor + '.' + this.patch;
+  SemVer.prototype.toString = function () {
+    return this.version
+  };
 
-      if (this.prerelease.length) {
-        this.version += '-' + this.prerelease.join('.');
-      }
+  SemVer.prototype.compare = function (other) {
+    debug('SemVer.compare', this.version, this.options, other);
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options);
+    }
 
-      return this.version;
-    };
+    return this.compareMain(other) || this.comparePre(other)
+  };
 
-    SemVer.prototype.toString = function () {
-      return this.version;
-    };
+  SemVer.prototype.compareMain = function (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options);
+    }
 
-    SemVer.prototype.compare = function (other) {
-      debug('SemVer.compare', this.version, this.options, other);
+    return compareIdentifiers(this.major, other.major) ||
+           compareIdentifiers(this.minor, other.minor) ||
+           compareIdentifiers(this.patch, other.patch)
+  };
 
-      if (!(other instanceof SemVer)) {
-        other = new SemVer(other, this.options);
+  SemVer.prototype.comparePre = function (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
+    }
+
+    var i = 0;
+    do {
+      var a = this.prerelease[i];
+      var 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)
+  };
 
-      return this.compareMain(other) || this.comparePre(other);
-    };
-
-    SemVer.prototype.compareMain = function (other) {
-      if (!(other instanceof SemVer)) {
-        other = new SemVer(other, this.options);
+  SemVer.prototype.compareBuild = function (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options);
+    }
+
+    var i = 0;
+    do {
+      var a = this.build[i];
+      var b = other.build[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)
+  };
 
-      return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
-    };
-
-    SemVer.prototype.comparePre = function (other) {
-      if (!(other instanceof SemVer)) {
-        other = new SemVer(other, this.options);
-      } // NOT having a prerelease is > having one
-
+  // preminor will bump the version up to the next minor release, and immediately
+  // down to pre-release. premajor and prepatch work the same way.
+  SemVer.prototype.inc = function (release, identifier) {
+    switch (release) {
+      case 'premajor':
+        this.prerelease.length = 0;
+        this.patch = 0;
+        this.minor = 0;
+        this.major++;
+        this.inc('pre', identifier);
+        break
+      case 'preminor':
+        this.prerelease.length = 0;
+        this.patch = 0;
+        this.minor++;
+        this.inc('pre', identifier);
+        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);
+        this.inc('pre', identifier);
+        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);
+        }
+        this.inc('pre', identifier);
+        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':
+        if (this.prerelease.length === 0) {
+          this.prerelease = [0];
+        } else {
+          var 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
+            this.prerelease.push(0);
+          }
+        }
+        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
+          if (this.prerelease[0] === identifier) {
+            if (isNaN(this.prerelease[1])) {
+              this.prerelease = [identifier, 0];
+            }
+          } else {
+            this.prerelease = [identifier, 0];
+          }
+        }
+        break
 
-      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;
-      }
+      default:
+        throw new Error('invalid increment argument: ' + release)
+    }
+    this.format();
+    this.raw = this.version;
+    return this
+  };
 
-      var i = 0;
+  exports.inc = inc;
+  function inc (version, release, loose, identifier) {
+    if (typeof (loose) === 'string') {
+      identifier = loose;
+      loose = undefined;
+    }
 
-      do {
-        var a = this.prerelease[i];
-        var b = other.prerelease[i];
-        debug('prerelease compare', i, a, b);
+    try {
+      return new SemVer(version, loose).inc(release, identifier).version
+    } catch (er) {
+      return null
+    }
+  }
 
-        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);
+  exports.diff = diff;
+  function diff (version1, version2) {
+    if (eq(version1, version2)) {
+      return null
+    } else {
+      var v1 = parse(version1);
+      var v2 = parse(version2);
+      var prefix = '';
+      if (v1.prerelease.length || v2.prerelease.length) {
+        prefix = 'pre';
+        var defaultResult = 'prerelease';
+      }
+      for (var key in v1) {
+        if (key === 'major' || key === 'minor' || key === 'patch') {
+          if (v1[key] !== v2[key]) {
+            return prefix + key
+          }
         }
-      } while (++i);
-    };
-
-    SemVer.prototype.compareBuild = function (other) {
-      if (!(other instanceof SemVer)) {
-        other = new SemVer(other, this.options);
       }
+      return defaultResult // may be undefined
+    }
+  }
 
-      var i = 0;
-
-      do {
-        var a = this.build[i];
-        var b = other.build[i];
-        debug('prerelease compare', i, a, b);
+  exports.compareIdentifiers = compareIdentifiers;
 
-        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);
-    }; // preminor will bump the version up to the next minor release, and immediately
-    // down to pre-release. premajor and prepatch work the same way.
+  var numeric = /^[0-9]+$/;
+  function compareIdentifiers (a, b) {
+    var anum = numeric.test(a);
+    var bnum = numeric.test(b);
 
+    if (anum && bnum) {
+      a = +a;
+      b = +b;
+    }
 
-    SemVer.prototype.inc = function (release, identifier) {
-      switch (release) {
-        case 'premajor':
-          this.prerelease.length = 0;
-          this.patch = 0;
-          this.minor = 0;
-          this.major++;
-          this.inc('pre', identifier);
-          break;
+    return a === b ? 0
+      : (anum && !bnum) ? -1
+      : (bnum && !anum) ? 1
+      : a < b ? -1
+      : 1
+  }
 
-        case 'preminor':
-          this.prerelease.length = 0;
-          this.patch = 0;
-          this.minor++;
-          this.inc('pre', identifier);
-          break;
+  exports.rcompareIdentifiers = rcompareIdentifiers;
+  function rcompareIdentifiers (a, b) {
+    return compareIdentifiers(b, a)
+  }
 
-        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);
-          this.inc('pre', identifier);
-          break;
-        // If the input is a non-prerelease version, this acts the same as
-        // prepatch.
+  exports.major = major;
+  function major (a, loose) {
+    return new SemVer(a, loose).major
+  }
 
-        case 'prerelease':
-          if (this.prerelease.length === 0) {
-            this.inc('patch', identifier);
-          }
+  exports.minor = minor;
+  function minor (a, loose) {
+    return new SemVer(a, loose).minor
+  }
 
-          this.inc('pre', identifier);
-          break;
+  exports.patch = patch;
+  function patch (a, loose) {
+    return new SemVer(a, loose).patch
+  }
 
-        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++;
-          }
+  exports.compare = compare;
+  function compare (a, b, loose) {
+    return new SemVer(a, loose).compare(new SemVer(b, loose))
+  }
 
-          this.minor = 0;
-          this.patch = 0;
-          this.prerelease = [];
-          break;
+  exports.compareLoose = compareLoose;
+  function compareLoose (a, b) {
+    return compare(a, b, true)
+  }
 
-        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++;
-          }
+  exports.compareBuild = compareBuild;
+  function compareBuild (a, b, loose) {
+    var versionA = new SemVer(a, loose);
+    var versionB = new SemVer(b, loose);
+    return versionA.compare(versionB) || versionA.compareBuild(versionB)
+  }
 
-          this.patch = 0;
-          this.prerelease = [];
-          break;
+  exports.rcompare = rcompare;
+  function rcompare (a, b, loose) {
+    return compare(b, a, loose)
+  }
 
-        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++;
-          }
+  exports.sort = sort;
+  function sort (list, loose) {
+    return list.sort(function (a, b) {
+      return exports.compareBuild(a, b, loose)
+    })
+  }
 
-          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.
+  exports.rsort = rsort;
+  function rsort (list, loose) {
+    return list.sort(function (a, b) {
+      return exports.compareBuild(b, a, loose)
+    })
+  }
 
-        case 'pre':
-          if (this.prerelease.length === 0) {
-            this.prerelease = [0];
-          } else {
-            var i = this.prerelease.length;
+  exports.gt = gt;
+  function gt (a, b, loose) {
+    return compare(a, b, loose) > 0
+  }
 
-            while (--i >= 0) {
-              if (typeof this.prerelease[i] === 'number') {
-                this.prerelease[i]++;
-                i = -2;
-              }
-            }
+  exports.lt = lt;
+  function lt (a, b, loose) {
+    return compare(a, b, loose) < 0
+  }
 
-            if (i === -1) {
-              // didn't increment anything
-              this.prerelease.push(0);
-            }
-          }
+  exports.eq = eq;
+  function eq (a, b, loose) {
+    return compare(a, b, loose) === 0
+  }
 
-          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
-            if (this.prerelease[0] === identifier) {
-              if (isNaN(this.prerelease[1])) {
-                this.prerelease = [identifier, 0];
-              }
-            } else {
-              this.prerelease = [identifier, 0];
-            }
-          }
+  exports.neq = neq;
+  function neq (a, b, loose) {
+    return compare(a, b, loose) !== 0
+  }
 
-          break;
+  exports.gte = gte;
+  function gte (a, b, loose) {
+    return compare(a, b, loose) >= 0
+  }
 
-        default:
-          throw new Error('invalid increment argument: ' + release);
-      }
+  exports.lte = lte;
+  function lte (a, b, loose) {
+    return compare(a, b, loose) <= 0
+  }
 
-      this.format();
-      this.raw = this.version;
-      return this;
-    };
+  exports.cmp = cmp;
+  function 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
 
-    exports.inc = inc;
+      case '!==':
+        if (typeof a === 'object')
+          a = a.version;
+        if (typeof b === 'object')
+          b = b.version;
+        return a !== b
 
-    function inc(version, release, loose, identifier) {
-      if (typeof loose === 'string') {
-        identifier = loose;
-        loose = undefined;
-      }
+      case '':
+      case '=':
+      case '==':
+        return eq(a, b, loose)
 
-      try {
-        return new SemVer(version, loose).inc(release, identifier).version;
-      } catch (er) {
-        return null;
-      }
-    }
+      case '!=':
+        return neq(a, b, loose)
 
-    exports.diff = diff;
+      case '>':
+        return gt(a, b, loose)
 
-    function diff(version1, version2) {
-      if (eq(version1, version2)) {
-        return null;
-      } else {
-        var v1 = parse(version1);
-        var v2 = parse(version2);
-        var prefix = '';
+      case '>=':
+        return gte(a, b, loose)
 
-        if (v1.prerelease.length || v2.prerelease.length) {
-          prefix = 'pre';
-          var defaultResult = 'prerelease';
-        }
+      case '<':
+        return lt(a, b, loose)
 
-        for (var key in v1) {
-          if (key === 'major' || key === 'minor' || key === 'patch') {
-            if (v1[key] !== v2[key]) {
-              return prefix + key;
-            }
-          }
-        }
+      case '<=':
+        return lte(a, b, loose)
 
-        return defaultResult; // may be undefined
-      }
+      default:
+        throw new TypeError('Invalid operator: ' + op)
     }
+  }
 
-    exports.compareIdentifiers = compareIdentifiers;
-    var numeric = /^[0-9]+$/;
-
-    function compareIdentifiers(a, b) {
-      var anum = numeric.test(a);
-      var bnum = numeric.test(b);
+  exports.Comparator = Comparator;
+  function Comparator (comp, options) {
+    if (!options || typeof options !== 'object') {
+      options = {
+        loose: !!options,
+        includePrerelease: false
+      };
+    }
 
-      if (anum && bnum) {
-        a = +a;
-        b = +b;
+    if (comp instanceof Comparator) {
+      if (comp.loose === !!options.loose) {
+        return comp
+      } else {
+        comp = comp.value;
       }
+    }
 
-      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+    if (!(this instanceof Comparator)) {
+      return new Comparator(comp, options)
     }
 
-    exports.rcompareIdentifiers = rcompareIdentifiers;
+    debug('comparator', comp, options);
+    this.options = options;
+    this.loose = !!options.loose;
+    this.parse(comp);
 
-    function rcompareIdentifiers(a, b) {
-      return compareIdentifiers(b, a);
+    if (this.semver === ANY) {
+      this.value = '';
+    } else {
+      this.value = this.operator + this.semver.version;
     }
 
-    exports.major = major;
+    debug('comp', this);
+  }
+
+  var ANY = {};
+  Comparator.prototype.parse = function (comp) {
+    var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+    var m = comp.match(r);
 
-    function major(a, loose) {
-      return new SemVer(a, loose).major;
+    if (!m) {
+      throw new TypeError('Invalid comparator: ' + comp)
     }
 
-    exports.minor = minor;
-
-    function minor(a, loose) {
-      return new SemVer(a, loose).minor;
+    this.operator = m[1] !== undefined ? m[1] : '';
+    if (this.operator === '=') {
+      this.operator = '';
     }
 
-    exports.patch = patch;
-
-    function patch(a, loose) {
-      return new SemVer(a, loose).patch;
-    }
-
-    exports.compare = compare;
-
-    function compare(a, b, loose) {
-      return new SemVer(a, loose).compare(new SemVer(b, loose));
-    }
-
-    exports.compareLoose = compareLoose;
-
-    function compareLoose(a, b) {
-      return compare(a, b, true);
-    }
-
-    exports.compareBuild = compareBuild;
-
-    function compareBuild(a, b, loose) {
-      var versionA = new SemVer(a, loose);
-      var versionB = new SemVer(b, loose);
-      return versionA.compare(versionB) || versionA.compareBuild(versionB);
-    }
-
-    exports.rcompare = rcompare;
-
-    function rcompare(a, b, loose) {
-      return compare(b, a, loose);
+    // 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);
     }
+  };
 
-    exports.sort = sort;
-
-    function sort(list, loose) {
-      return list.sort(function (a, b) {
-        return exports.compareBuild(a, b, loose);
-      });
-    }
+  Comparator.prototype.toString = function () {
+    return this.value
+  };
 
-    exports.rsort = rsort;
+  Comparator.prototype.test = function (version) {
+    debug('Comparator.test', version, this.options.loose);
 
-    function rsort(list, loose) {
-      return list.sort(function (a, b) {
-        return exports.compareBuild(b, a, loose);
-      });
+    if (this.semver === ANY || version === ANY) {
+      return true
     }
 
-    exports.gt = gt;
-
-    function gt(a, b, loose) {
-      return compare(a, b, loose) > 0;
+    if (typeof version === 'string') {
+      try {
+        version = new SemVer(version, this.options);
+      } catch (er) {
+        return false
+      }
     }
 
-    exports.lt = lt;
+    return cmp(version, this.operator, this.semver, this.options)
+  };
 
-    function lt(a, b, loose) {
-      return compare(a, b, loose) < 0;
+  Comparator.prototype.intersects = function (comp, options) {
+    if (!(comp instanceof Comparator)) {
+      throw new TypeError('a Comparator is required')
     }
 
-    exports.eq = eq;
-
-    function eq(a, b, loose) {
-      return compare(a, b, loose) === 0;
+    if (!options || typeof options !== 'object') {
+      options = {
+        loose: !!options,
+        includePrerelease: false
+      };
     }
 
-    exports.neq = neq;
+    var rangeTmp;
+
+    if (this.operator === '') {
+      if (this.value === '') {
+        return true
+      }
+      rangeTmp = new Range(comp.value, options);
+      return satisfies(this.value, rangeTmp, options)
+    } else if (comp.operator === '') {
+      if (comp.value === '') {
+        return true
+      }
+      rangeTmp = new Range(this.value, options);
+      return satisfies(comp.semver, rangeTmp, options)
+    }
+
+    var sameDirectionIncreasing =
+      (this.operator === '>=' || this.operator === '>') &&
+      (comp.operator === '>=' || comp.operator === '>');
+    var sameDirectionDecreasing =
+      (this.operator === '<=' || this.operator === '<') &&
+      (comp.operator === '<=' || comp.operator === '<');
+    var sameSemVer = this.semver.version === comp.semver.version;
+    var differentDirectionsInclusive =
+      (this.operator === '>=' || this.operator === '<=') &&
+      (comp.operator === '>=' || comp.operator === '<=');
+    var oppositeDirectionsLessThan =
+      cmp(this.semver, '<', comp.semver, options) &&
+      ((this.operator === '>=' || this.operator === '>') &&
+      (comp.operator === '<=' || comp.operator === '<'));
+    var oppositeDirectionsGreaterThan =
+      cmp(this.semver, '>', comp.semver, options) &&
+      ((this.operator === '<=' || this.operator === '<') &&
+      (comp.operator === '>=' || comp.operator === '>'));
+
+    return sameDirectionIncreasing || sameDirectionDecreasing ||
+      (sameSemVer && differentDirectionsInclusive) ||
+      oppositeDirectionsLessThan || oppositeDirectionsGreaterThan
+  };
 
-    function neq(a, b, loose) {
-      return compare(a, b, loose) !== 0;
+  exports.Range = Range;
+  function Range (range, options) {
+    if (!options || typeof options !== 'object') {
+      options = {
+        loose: !!options,
+        includePrerelease: false
+      };
     }
 
-    exports.gte = gte;
-
-    function gte(a, b, loose) {
-      return compare(a, b, loose) >= 0;
+    if (range instanceof Range) {
+      if (range.loose === !!options.loose &&
+          range.includePrerelease === !!options.includePrerelease) {
+        return range
+      } else {
+        return new Range(range.raw, options)
+      }
     }
 
-    exports.lte = lte;
-
-    function lte(a, b, loose) {
-      return compare(a, b, loose) <= 0;
+    if (range instanceof Comparator) {
+      return new Range(range.value, options)
     }
 
-    exports.cmp = cmp;
-
-    function 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);
-      }
+    if (!(this instanceof Range)) {
+      return new Range(range, options)
     }
 
-    exports.Comparator = Comparator;
-
-    function Comparator(comp, options) {
-      if (!options || typeof options !== 'object') {
-        options = {
-          loose: !!options,
-          includePrerelease: false
-        };
-      }
+    this.options = options;
+    this.loose = !!options.loose;
+    this.includePrerelease = !!options.includePrerelease;
 
-      if (comp instanceof Comparator) {
-        if (comp.loose === !!options.loose) {
-          return comp;
-        } else {
-          comp = comp.value;
-        }
-      }
-
-      if (!(this instanceof Comparator)) {
-        return new Comparator(comp, options);
-      }
-
-      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;
-      }
+    // First, split based on boolean or ||
+    this.raw = range;
+    this.set = range.split(/\s*\|\|\s*/).map(function (range) {
+      return this.parseRange(range.trim())
+    }, this).filter(function (c) {
+      // throw out any that are not relevant for whatever reason
+      return c.length
+    });
 
-      debug('comp', this);
+    if (!this.set.length) {
+      throw new TypeError('Invalid SemVer Range: ' + range)
     }
 
-    var ANY = {};
-
-    Comparator.prototype.parse = function (comp) {
-      var r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
-      var 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);
-      }
-    };
-
-    Comparator.prototype.toString = function () {
-      return this.value;
-    };
-
-    Comparator.prototype.test = function (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);
-    };
-
-    Comparator.prototype.intersects = function (comp, options) {
-      if (!(comp instanceof Comparator)) {
-        throw new TypeError('a Comparator is required');
-      }
-
-      if (!options || typeof options !== 'object') {
-        options = {
-          loose: !!options,
-          includePrerelease: false
-        };
-      }
-
-      var rangeTmp;
-
-      if (this.operator === '') {
-        if (this.value === '') {
-          return true;
-        }
-
-        rangeTmp = new Range(comp.value, options);
-        return satisfies(this.value, rangeTmp, options);
-      } else if (comp.operator === '') {
-        if (comp.value === '') {
-          return true;
-        }
-
-        rangeTmp = new Range(this.value, options);
-        return satisfies(comp.semver, rangeTmp, options);
-      }
-
-      var sameDirectionIncreasing = (this.operator === '>=' || this.operator === '>') && (comp.operator === '>=' || comp.operator === '>');
-      var sameDirectionDecreasing = (this.operator === '<=' || this.operator === '<') && (comp.operator === '<=' || comp.operator === '<');
-      var sameSemVer = this.semver.version === comp.semver.version;
-      var differentDirectionsInclusive = (this.operator === '>=' || this.operator === '<=') && (comp.operator === '>=' || comp.operator === '<=');
-      var oppositeDirectionsLessThan = cmp(this.semver, '<', comp.semver, options) && (this.operator === '>=' || this.operator === '>') && (comp.operator === '<=' || comp.operator === '<');
-      var oppositeDirectionsGreaterThan = cmp(this.semver, '>', comp.semver, options) && (this.operator === '<=' || this.operator === '<') && (comp.operator === '>=' || comp.operator === '>');
-      return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
-    };
-
-    exports.Range = Range;
-
-    function Range(range, options) {
-      if (!options || typeof options !== 'object') {
-        options = {
-          loose: !!options,
-          includePrerelease: false
-        };
-      }
-
-      if (range instanceof Range) {
-        if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
-          return range;
-        } else {
-          return new Range(range.raw, options);
-        }
-      }
+    this.format();
+  }
 
-      if (range instanceof Comparator) {
-        return new Range(range.value, options);
-      }
+  Range.prototype.format = function () {
+    this.range = this.set.map(function (comps) {
+      return comps.join(' ').trim()
+    }).join('||').trim();
+    return this.range
+  };
 
-      if (!(this instanceof Range)) {
-        return new Range(range, options);
-      }
+  Range.prototype.toString = function () {
+    return this.range
+  };
 
-      this.options = options;
-      this.loose = !!options.loose;
-      this.includePrerelease = !!options.includePrerelease; // First, split based on boolean or ||
-
-      this.raw = range;
-      this.set = range.split(/\s*\|\|\s*/).map(function (range) {
-        return this.parseRange(range.trim());
-      }, this).filter(function (c) {
-        // throw out any that are not relevant for whatever reason
-        return c.length;
+  Range.prototype.parseRange = function (range) {
+    var loose = this.options.loose;
+    range = range.trim();
+    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+    var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+    range = range.replace(hr, hyphenReplace);
+    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, re[t.COMPARATORTRIM]);
+
+    // `~ 1.2.3` => `~1.2.3`
+    range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+
+    // `^ 1.2.3` => `^1.2.3`
+    range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+
+    // normalize spaces
+    range = range.split(/\s+/).join(' ');
+
+    // At this point, the range is completely trimmed and
+    // ready to be split into comparators.
+
+    var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+    var set = range.split(' ').map(function (comp) {
+      return parseComparator(comp, this.options)
+    }, this).join(' ').split(/\s+/);
+    if (this.options.loose) {
+      // in loose mode, throw out any that are not valid comparators
+      set = set.filter(function (comp) {
+        return !!comp.match(compRe)
       });
-
-      if (!this.set.length) {
-        throw new TypeError('Invalid SemVer Range: ' + range);
-      }
-
-      this.format();
     }
+    set = set.map(function (comp) {
+      return new Comparator(comp, this.options)
+    }, this);
 
-    Range.prototype.format = function () {
-      this.range = this.set.map(function (comps) {
-        return comps.join(' ').trim();
-      }).join('||').trim();
-      return this.range;
-    };
-
-    Range.prototype.toString = function () {
-      return this.range;
-    };
-
-    Range.prototype.parseRange = function (range) {
-      var loose = this.options.loose;
-      range = range.trim(); // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
-
-      var hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
-      range = range.replace(hr, hyphenReplace);
-      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, re[t.COMPARATORTRIM]); // `~ 1.2.3` => `~1.2.3`
-
-      range = range.replace(re[t.TILDETRIM], tildeTrimReplace); // `^ 1.2.3` => `^1.2.3`
-
-      range = range.replace(re[t.CARETTRIM], caretTrimReplace); // normalize spaces
-
-      range = range.split(/\s+/).join(' '); // At this point, the range is completely trimmed and
-      // ready to be split into comparators.
-
-      var compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
-      var set = range.split(' ').map(function (comp) {
-        return parseComparator(comp, this.options);
-      }, this).join(' ').split(/\s+/);
-
-      if (this.options.loose) {
-        // in loose mode, throw out any that are not valid comparators
-        set = set.filter(function (comp) {
-          return !!comp.match(compRe);
-        });
-      }
-
-      set = set.map(function (comp) {
-        return new Comparator(comp, this.options);
-      }, this);
-      return set;
-    };
-
-    Range.prototype.intersects = function (range, options) {
-      if (!(range instanceof Range)) {
-        throw new TypeError('a Range is required');
-      }
-
-      return this.set.some(function (thisComparators) {
-        return isSatisfiable(thisComparators, options) && range.set.some(function (rangeComparators) {
-          return isSatisfiable(rangeComparators, options) && thisComparators.every(function (thisComparator) {
-            return rangeComparators.every(function (rangeComparator) {
-              return thisComparator.intersects(rangeComparator, options);
-            });
-          });
-        });
-      });
-    }; // take a set of comparators and determine whether there
-    // exists a version which can satisfy it
-
-
-    function isSatisfiable(comparators, options) {
-      var result = true;
-      var remainingComparators = comparators.slice();
-      var testComparator = remainingComparators.pop();
-
-      while (result && remainingComparators.length) {
-        result = remainingComparators.every(function (otherComparator) {
-          return testComparator.intersects(otherComparator, options);
-        });
-        testComparator = remainingComparators.pop();
-      }
+    return set
+  };
 
-      return result;
-    } // Mostly just for testing and legacy API reasons
+  Range.prototype.intersects = function (range, options) {
+    if (!(range instanceof Range)) {
+      throw new TypeError('a Range is required')
+    }
 
+    return this.set.some(function (thisComparators) {
+      return (
+        isSatisfiable(thisComparators, options) &&
+        range.set.some(function (rangeComparators) {
+          return (
+            isSatisfiable(rangeComparators, options) &&
+            thisComparators.every(function (thisComparator) {
+              return rangeComparators.every(function (rangeComparator) {
+                return thisComparator.intersects(rangeComparator, options)
+              })
+            })
+          )
+        })
+      )
+    })
+  };
 
-    exports.toComparators = toComparators;
+  // take a set of comparators and determine whether there
+  // exists a version which can satisfy it
+  function isSatisfiable (comparators, options) {
+    var result = true;
+    var remainingComparators = comparators.slice();
+    var testComparator = remainingComparators.pop();
 
-    function toComparators(range, options) {
-      return new Range(range, options).set.map(function (comp) {
-        return comp.map(function (c) {
-          return c.value;
-        }).join(' ').trim().split(' ');
+    while (result && remainingComparators.length) {
+      result = remainingComparators.every(function (otherComparator) {
+        return testComparator.intersects(otherComparator, options)
       });
-    } // comprised of xranges, tildes, stars, and gtlt's at this point.
-    // already replaced the hyphen ranges
-    // turn into a set of JUST comparators.
-
-
-    function 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;
-    }
-
-    function isX(id) {
-      return !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
-    // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
-    // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
-    // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
-    // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
-
-
-    function replaceTildes(comp, options) {
-      return comp.trim().split(/\s+/).map(function (comp) {
-        return replaceTilde(comp, options);
-      }).join(' ');
-    }
 
-    function replaceTilde(comp, options) {
-      var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
-      return comp.replace(r, function (_, M, m, p, pr) {
-        debug('tilde', comp, _, M, m, p, pr);
-        var ret;
-
-        if (isX(M)) {
-          ret = '';
-        } else if (isX(m)) {
-          ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
-        } else if (isX(p)) {
-          // ~1.2 == >=1.2.0 <1.3.0
+      testComparator = remainingComparators.pop();
+    }
+
+    return result
+  }
+
+  // Mostly just for testing and legacy API reasons
+  exports.toComparators = toComparators;
+  function toComparators (range, options) {
+    return new Range(range, options).set.map(function (comp) {
+      return comp.map(function (c) {
+        return c.value
+      }).join(' ').trim().split(' ')
+    })
+  }
+
+  // comprised of xranges, tildes, stars, and gtlt's at this point.
+  // already replaced the hyphen ranges
+  // turn into a set of JUST comparators.
+  function 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
+  }
+
+  function isX (id) {
+    return !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
+  // ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
+  // ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
+  // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
+  // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
+  function replaceTildes (comp, options) {
+    return comp.trim().split(/\s+/).map(function (comp) {
+      return replaceTilde(comp, options)
+    }).join(' ')
+  }
+
+  function replaceTilde (comp, options) {
+    var r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+    return comp.replace(r, function (_, M, m, p, pr) {
+      debug('tilde', comp, _, M, m, p, pr);
+      var ret;
+
+      if (isX(M)) {
+        ret = '';
+      } else if (isX(m)) {
+        ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+      } else if (isX(p)) {
+        // ~1.2 == >=1.2.0 <1.3.0
+        ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
+      } else if (pr) {
+        debug('replaceTilde pr', pr);
+        ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+              ' <' + M + '.' + (+m + 1) + '.0';
+      } else {
+        // ~1.2.3 == >=1.2.3 <1.3.0
+        ret = '>=' + M + '.' + m + '.' + p +
+              ' <' + M + '.' + (+m + 1) + '.0';
+      }
+
+      debug('tilde return', ret);
+      return ret
+    })
+  }
+
+  // ^ --> * (any, kinda silly)
+  // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
+  // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
+  // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
+  // ^1.2.3 --> >=1.2.3 <2.0.0
+  // ^1.2.0 --> >=1.2.0 <2.0.0
+  function replaceCarets (comp, options) {
+    return comp.trim().split(/\s+/).map(function (comp) {
+      return replaceCaret(comp, options)
+    }).join(' ')
+  }
+
+  function replaceCaret (comp, options) {
+    debug('caret', comp, options);
+    var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+    return comp.replace(r, function (_, M, m, p, pr) {
+      debug('caret', comp, _, M, m, p, pr);
+      var ret;
+
+      if (isX(M)) {
+        ret = '';
+      } else if (isX(m)) {
+        ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
+      } else if (isX(p)) {
+        if (M === '0') {
           ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
-        } else if (pr) {
-          debug('replaceTilde pr', pr);
-          ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + (+m + 1) + '.0';
         } else {
-          // ~1.2.3 == >=1.2.3 <1.3.0
-          ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + (+m + 1) + '.0';
-        }
-
-        debug('tilde return', ret);
-        return ret;
-      });
-    } // ^ --> * (any, kinda silly)
-    // ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0
-    // ^2.0, ^2.0.x --> >=2.0.0 <3.0.0
-    // ^1.2, ^1.2.x --> >=1.2.0 <2.0.0
-    // ^1.2.3 --> >=1.2.3 <2.0.0
-    // ^1.2.0 --> >=1.2.0 <2.0.0
-
-
-    function replaceCarets(comp, options) {
-      return comp.trim().split(/\s+/).map(function (comp) {
-        return replaceCaret(comp, options);
-      }).join(' ');
-    }
-
-    function replaceCaret(comp, options) {
-      debug('caret', comp, options);
-      var r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
-      return comp.replace(r, function (_, M, m, p, pr) {
-        debug('caret', comp, _, M, m, p, pr);
-        var ret;
-
-        if (isX(M)) {
-          ret = '';
-        } else if (isX(m)) {
-          ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0';
-        } else if (isX(p)) {
-          if (M === '0') {
-            ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0';
-          } else {
-            ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0';
-          }
-        } else if (pr) {
-          debug('replaceCaret pr', pr);
-
-          if (M === '0') {
-            if (m === '0') {
-              ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + m + '.' + (+p + 1);
-            } else {
-              ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + M + '.' + (+m + 1) + '.0';
-            }
+          ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0';
+        }
+      } else if (pr) {
+        debug('replaceCaret pr', pr);
+        if (M === '0') {
+          if (m === '0') {
+            ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+                  ' <' + M + '.' + m + '.' + (+p + 1);
           } else {
-            ret = '>=' + M + '.' + m + '.' + p + '-' + pr + ' <' + (+M + 1) + '.0.0';
+            ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+                  ' <' + M + '.' + (+m + 1) + '.0';
           }
         } else {
-          debug('no pr');
-
-          if (M === '0') {
-            if (m === '0') {
-              ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + m + '.' + (+p + 1);
-            } else {
-              ret = '>=' + M + '.' + m + '.' + p + ' <' + M + '.' + (+m + 1) + '.0';
-            }
+          ret = '>=' + M + '.' + m + '.' + p + '-' + pr +
+                ' <' + (+M + 1) + '.0.0';
+        }
+      } else {
+        debug('no pr');
+        if (M === '0') {
+          if (m === '0') {
+            ret = '>=' + M + '.' + m + '.' + p +
+                  ' <' + M + '.' + m + '.' + (+p + 1);
           } else {
-            ret = '>=' + M + '.' + m + '.' + p + ' <' + (+M + 1) + '.0.0';
+            ret = '>=' + M + '.' + m + '.' + p +
+                  ' <' + M + '.' + (+m + 1) + '.0';
           }
+        } else {
+          ret = '>=' + M + '.' + m + '.' + p +
+                ' <' + (+M + 1) + '.0.0';
         }
+      }
 
-        debug('caret return', ret);
-        return ret;
-      });
-    }
-
-    function replaceXRanges(comp, options) {
-      debug('replaceXRanges', comp, options);
-      return comp.split(/\s+/).map(function (comp) {
-        return replaceXRange(comp, options);
-      }).join(' ');
-    }
+      debug('caret return', ret);
+      return ret
+    })
+  }
 
-    function replaceXRange(comp, options) {
-      comp = comp.trim();
-      var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
-      return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
-        debug('xRange', comp, ret, gtlt, M, m, p, pr);
-        var xM = isX(M);
-        var xm = xM || isX(m);
-        var xp = xm || isX(p);
-        var anyX = xp;
+  function replaceXRanges (comp, options) {
+    debug('replaceXRanges', comp, options);
+    return comp.split(/\s+/).map(function (comp) {
+      return replaceXRange(comp, options)
+    }).join(' ')
+  }
 
-        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
+  function replaceXRange (comp, options) {
+    comp = comp.trim();
+    var r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+    return comp.replace(r, function (ret, gtlt, M, m, p, pr) {
+      debug('xRange', comp, ret, gtlt, M, m, p, pr);
+      var xM = isX(M);
+      var xm = xM || isX(m);
+      var xp = xm || isX(p);
+      var anyX = xp;
 
+      if (gtlt === '=' && anyX) {
+        gtlt = '';
+      }
 
-        pr = options.includePrerelease ? '-0' : '';
+      // 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) {
+        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
+          // >1.2.3 => >= 1.2.4
+          gtlt = '>=';
           if (xm) {
+            M = +M + 1;
             m = 0;
+            p = 0;
+          } else {
+            m = +m + 1;
+            p = 0;
           }
-
-          p = 0;
-
-          if (gtlt === '>') {
-            // >1 => >=2.0.0
-            // >1.2 => >=1.3.0
-            // >1.2.3 => >= 1.2.4
-            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;
-            }
+        } 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;
           }
-
-          ret = gtlt + M + '.' + m + '.' + p + pr;
-        } else if (xm) {
-          ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr;
-        } else if (xp) {
-          ret = '>=' + M + '.' + m + '.0' + pr + ' <' + M + '.' + (+m + 1) + '.0' + pr;
         }
 
-        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.
-
+        ret = gtlt + M + '.' + m + '.' + p + pr;
+      } else if (xm) {
+        ret = '>=' + M + '.0.0' + pr + ' <' + (+M + 1) + '.0.0' + pr;
+      } else if (xp) {
+        ret = '>=' + M + '.' + m + '.0' + pr +
+          ' <' + M + '.' + (+m + 1) + '.0' + pr;
+      }
 
-    function replaceStars(comp, options) {
-      debug('replaceStars', comp, options); // Looseness is ignored here.  star is always as loose as it gets!
+      debug('xRange return', ret);
 
-      return comp.trim().replace(re[t.STAR], '');
-    } // 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 Any 3.4.x will do
-    // 1.2 - 3.4 => >=1.2.0 <3.5.0
+      return ret
+    })
+  }
 
+  // Because * is AND-ed with everything else in the comparator,
+  // and '' means "any version", just remove the *s entirely.
+  function 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], '')
+  }
 
-    function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
-      if (isX(fM)) {
-        from = '';
-      } else if (isX(fm)) {
-        from = '>=' + fM + '.0.0';
-      } else if (isX(fp)) {
-        from = '>=' + fM + '.' + fm + '.0';
-      } else {
-        from = '>=' + from;
-      }
+  // 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 Any 3.4.x will do
+  // 1.2 - 3.4 => >=1.2.0 <3.5.0
+  function hyphenReplace ($0,
+    from, fM, fm, fp, fpr, fb,
+    to, tM, tm, tp, tpr, tb) {
+    if (isX(fM)) {
+      from = '';
+    } else if (isX(fm)) {
+      from = '>=' + fM + '.0.0';
+    } else if (isX(fp)) {
+      from = '>=' + fM + '.' + fm + '.0';
+    } else {
+      from = '>=' + from;
+    }
 
-      if (isX(tM)) {
-        to = '';
-      } else if (isX(tm)) {
-        to = '<' + (+tM + 1) + '.0.0';
-      } else if (isX(tp)) {
-        to = '<' + tM + '.' + (+tm + 1) + '.0';
-      } else if (tpr) {
-        to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr;
-      } else {
-        to = '<=' + to;
-      }
+    if (isX(tM)) {
+      to = '';
+    } else if (isX(tm)) {
+      to = '<' + (+tM + 1) + '.0.0';
+    } else if (isX(tp)) {
+      to = '<' + tM + '.' + (+tm + 1) + '.0';
+    } else if (tpr) {
+      to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr;
+    } else {
+      to = '<=' + to;
+    }
 
-      return (from + ' ' + to).trim();
-    } // if ANY of the sets match ALL of its comparators, then pass
+    return (from + ' ' + to).trim()
+  }
 
+  // if ANY of the sets match ALL of its comparators, then pass
+  Range.prototype.test = function (version) {
+    if (!version) {
+      return false
+    }
 
-    Range.prototype.test = function (version) {
-      if (!version) {
-        return false;
+    if (typeof version === 'string') {
+      try {
+        version = new SemVer(version, this.options);
+      } catch (er) {
+        return false
       }
+    }
 
-      if (typeof version === 'string') {
-        try {
-          version = new SemVer(version, this.options);
-        } catch (er) {
-          return false;
-        }
+    for (var i = 0; i < this.set.length; i++) {
+      if (testSet(this.set[i], version, this.options)) {
+        return true
       }
+    }
+    return false
+  };
 
-      for (var i = 0; i < this.set.length; i++) {
-        if (testSet(this.set[i], version, this.options)) {
-          return true;
-        }
+  function testSet (set, version, options) {
+    for (var i = 0; i < set.length; i++) {
+      if (!set[i].test(version)) {
+        return false
       }
+    }
 
-      return false;
-    };
-
-    function testSet(set, version, options) {
-      for (var 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 (i = 0; i < set.length; i++) {
+        debug(set[i].semver);
+        if (set[i].semver === ANY) {
+          continue
         }
-      }
-
-      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 (i = 0; i < set.length; i++) {
-          debug(set[i].semver);
-
-          if (set[i].semver === ANY) {
-            continue;
-          }
 
-          if (set[i].semver.prerelease.length > 0) {
-            var allowed = set[i].semver;
-
-            if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
-              return true;
-            }
+        if (set[i].semver.prerelease.length > 0) {
+          var allowed = set[i].semver;
+          if (allowed.major === version.major &&
+              allowed.minor === version.minor &&
+              allowed.patch === version.patch) {
+            return true
           }
-        } // Version has a -pre, but it's not one of the ones we like.
-
-
-        return false;
+        }
       }
 
-      return true;
+      // Version has a -pre, but it's not one of the ones we like.
+      return false
     }
 
-    exports.satisfies = satisfies;
-
-    function satisfies(version, range, options) {
-      try {
-        range = new Range(range, options);
-      } catch (er) {
-        return false;
-      }
+    return true
+  }
 
-      return range.test(version);
+  exports.satisfies = satisfies;
+  function satisfies (version, range, options) {
+    try {
+      range = new Range(range, options);
+    } catch (er) {
+      return false
     }
+    return range.test(version)
+  }
 
-    exports.maxSatisfying = maxSatisfying;
-
-    function maxSatisfying(versions, range, options) {
-      var max = null;
-      var maxSV = null;
-
-      try {
-        var rangeObj = new Range(range, options);
-      } catch (er) {
-        return null;
+  exports.maxSatisfying = maxSatisfying;
+  function maxSatisfying (versions, range, options) {
+    var max = null;
+    var maxSV = null;
+    try {
+      var rangeObj = new Range(range, options);
+    } catch (er) {
+      return null
+    }
+    versions.forEach(function (v) {
+      if (rangeObj.test(v)) {
+        // satisfies(v, range, options)
+        if (!max || maxSV.compare(v) === -1) {
+          // compare(max, v, true)
+          max = v;
+          maxSV = new SemVer(max, options);
+        }
       }
+    });
+    return max
+  }
 
-      versions.forEach(function (v) {
-        if (rangeObj.test(v)) {
-          // satisfies(v, range, options)
-          if (!max || maxSV.compare(v) === -1) {
-            // compare(max, v, true)
-            max = v;
-            maxSV = new SemVer(max, options);
-          }
-        }
-      });
-      return max;
+  exports.minSatisfying = minSatisfying;
+  function minSatisfying (versions, range, options) {
+    var min = null;
+    var minSV = null;
+    try {
+      var rangeObj = new Range(range, options);
+    } catch (er) {
+      return null
     }
+    versions.forEach(function (v) {
+      if (rangeObj.test(v)) {
+        // satisfies(v, range, options)
+        if (!min || minSV.compare(v) === 1) {
+          // compare(min, v, true)
+          min = v;
+          minSV = new SemVer(min, options);
+        }
+      }
+    });
+    return min
+  }
 
-    exports.minSatisfying = minSatisfying;
+  exports.minVersion = minVersion;
+  function minVersion (range, loose) {
+    range = new Range(range, loose);
 
-    function minSatisfying(versions, range, options) {
-      var min = null;
-      var minSV = null;
+    var minver = new SemVer('0.0.0');
+    if (range.test(minver)) {
+      return minver
+    }
 
-      try {
-        var rangeObj = new Range(range, options);
-      } catch (er) {
-        return null;
-      }
+    minver = new SemVer('0.0.0-0');
+    if (range.test(minver)) {
+      return minver
+    }
 
-      versions.forEach(function (v) {
-        if (rangeObj.test(v)) {
-          // satisfies(v, range, options)
-          if (!min || minSV.compare(v) === 1) {
-            // compare(min, v, true)
-            min = v;
-            minSV = new SemVer(min, options);
-          }
+    minver = null;
+    for (var i = 0; i < range.set.length; ++i) {
+      var comparators = range.set[i];
+
+      comparators.forEach(function (comparator) {
+        // Clone to avoid manipulating the comparator's semver object.
+        var compver = new SemVer(comparator.semver.version);
+        switch (comparator.operator) {
+          case '>':
+            if (compver.prerelease.length === 0) {
+              compver.patch++;
+            } else {
+              compver.prerelease.push(0);
+            }
+            compver.raw = compver.format();
+            /* fallthrough */
+          case '':
+          case '>=':
+            if (!minver || gt(minver, compver)) {
+              minver = compver;
+            }
+            break
+          case '<':
+          case '<=':
+            /* Ignore maximum versions */
+            break
+          /* istanbul ignore next */
+          default:
+            throw new Error('Unexpected operation: ' + comparator.operator)
         }
       });
-      return min;
     }
 
-    exports.minVersion = minVersion;
-
-    function minVersion(range, loose) {
-      range = new Range(range, loose);
-      var minver = new SemVer('0.0.0');
-
-      if (range.test(minver)) {
-        return minver;
-      }
-
-      minver = new SemVer('0.0.0-0');
-
-      if (range.test(minver)) {
-        return minver;
-      }
-
-      minver = null;
-
-      for (var i = 0; i < range.set.length; ++i) {
-        var comparators = range.set[i];
-        comparators.forEach(function (comparator) {
-          // Clone to avoid manipulating the comparator's semver object.
-          var compver = new SemVer(comparator.semver.version);
+    if (minver && range.test(minver)) {
+      return minver
+    }
 
-          switch (comparator.operator) {
-            case '>':
-              if (compver.prerelease.length === 0) {
-                compver.patch++;
-              } else {
-                compver.prerelease.push(0);
-              }
+    return null
+  }
 
-              compver.raw = compver.format();
+  exports.validRange = validRange;
+  function validRange (range, options) {
+    try {
+      // Return '*' instead of '' so that truthiness works.
+      // This will throw if it's invalid anyway
+      return new Range(range, options).range || '*'
+    } catch (er) {
+      return null
+    }
+  }
+
+  // Determine if version is less than all the versions possible in the range
+  exports.ltr = ltr;
+  function ltr (version, range, options) {
+    return outside(version, range, '<', options)
+  }
+
+  // Determine if version is greater than all the versions possible in the range.
+  exports.gtr = gtr;
+  function gtr (version, range, options) {
+    return outside(version, range, '>', options)
+  }
+
+  exports.outside = outside;
+  function outside (version, range, hilo, options) {
+    version = new SemVer(version, options);
+    range = new Range(range, options);
+
+    var gtfn, ltefn, ltfn, comp, ecomp;
+    switch (hilo) {
+      case '>':
+        gtfn = gt;
+        ltefn = lte;
+        ltfn = lt;
+        comp = '>';
+        ecomp = '>=';
+        break
+      case '<':
+        gtfn = lt;
+        ltefn = gte;
+        ltfn = gt;
+        comp = '<';
+        ecomp = '<=';
+        break
+      default:
+        throw new TypeError('Must provide a hilo val of "<" or ">"')
+    }
 
-            /* fallthrough */
+    // If it satisifes the range it is not outside
+    if (satisfies(version, range, options)) {
+      return false
+    }
 
-            case '':
-            case '>=':
-              if (!minver || gt(minver, compver)) {
-                minver = compver;
-              }
+    // From now on, variable terms are as if we're in "gtr" mode.
+    // but note that everything is flipped for the "ltr" function.
 
-              break;
+    for (var i = 0; i < range.set.length; ++i) {
+      var comparators = range.set[i];
 
-            case '<':
-            case '<=':
-              /* Ignore maximum versions */
-              break;
+      var high = null;
+      var low = null;
 
-            /* istanbul ignore next */
+      comparators.forEach(function (comparator) {
+        if (comparator.semver === ANY) {
+          comparator = new Comparator('>=0.0.0');
+        }
+        high = high || comparator;
+        low = low || comparator;
+        if (gtfn(comparator.semver, high.semver, options)) {
+          high = comparator;
+        } else if (ltfn(comparator.semver, low.semver, options)) {
+          low = comparator;
+        }
+      });
 
-            default:
-              throw new Error('Unexpected operation: ' + comparator.operator);
-          }
-        });
+      // If the edge version comparator has a operator then our version
+      // isn't outside it
+      if (high.operator === comp || high.operator === ecomp) {
+        return false
       }
 
-      if (minver && range.test(minver)) {
-        return minver;
+      // If the lowest version comparator has an operator and our version
+      // is less than it then it isn't higher than the range
+      if ((!low.operator || low.operator === comp) &&
+          ltefn(version, low.semver)) {
+        return false
+      } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+        return false
       }
-
-      return null;
     }
+    return true
+  }
 
-    exports.validRange = validRange;
-
-    function validRange(range, options) {
-      try {
-        // Return '*' instead of '' so that truthiness works.
-        // This will throw if it's invalid anyway
-        return new Range(range, options).range || '*';
-      } catch (er) {
-        return null;
-      }
-    } // Determine if version is less than all the versions possible in the range
-
-
-    exports.ltr = ltr;
-
-    function ltr(version, range, options) {
-      return outside(version, range, '<', options);
-    } // Determine if version is greater than all the versions possible in the range.
-
+  exports.prerelease = prerelease;
+  function prerelease (version, options) {
+    var parsed = parse(version, options);
+    return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
+  }
 
-    exports.gtr = gtr;
+  exports.intersects = intersects;
+  function intersects (r1, r2, options) {
+    r1 = new Range(r1, options);
+    r2 = new Range(r2, options);
+    return r1.intersects(r2)
+  }
 
-    function gtr(version, range, options) {
-      return outside(version, range, '>', options);
+  exports.coerce = coerce;
+  function coerce (version, options) {
+    if (version instanceof SemVer) {
+      return version
     }
 
-    exports.outside = outside;
-
-    function outside(version, range, hilo, options) {
-      version = new SemVer(version, options);
-      range = new Range(range, options);
-      var gtfn, ltefn, ltfn, comp, ecomp;
-
-      switch (hilo) {
-        case '>':
-          gtfn = gt;
-          ltefn = lte;
-          ltfn = lt;
-          comp = '>';
-          ecomp = '>=';
-          break;
-
-        case '<':
-          gtfn = lt;
-          ltefn = gte;
-          ltfn = gt;
-          comp = '<';
-          ecomp = '<=';
-          break;
-
-        default:
-          throw new TypeError('Must provide a hilo val of "<" or ">"');
-      } // If it satisifes the range it is not outside
-
-
-      if (satisfies(version, range, options)) {
-        return false;
-      } // From now on, variable terms are as if we're in "gtr" mode.
-      // but note that everything is flipped for the "ltr" function.
-
-
-      for (var i = 0; i < range.set.length; ++i) {
-        var comparators = range.set[i];
-        var high = null;
-        var low = null;
-        comparators.forEach(function (comparator) {
-          if (comparator.semver === ANY) {
-            comparator = new Comparator('>=0.0.0');
-          }
-
-          high = high || comparator;
-          low = low || comparator;
-
-          if (gtfn(comparator.semver, high.semver, options)) {
-            high = comparator;
-          } else if (ltfn(comparator.semver, low.semver, options)) {
-            low = comparator;
-          }
-        }); // If the edge version comparator has a operator then our version
-        // isn't outside it
+    if (typeof version === 'number') {
+      version = String(version);
+    }
 
-        if (high.operator === comp || high.operator === ecomp) {
-          return false;
-        } // If the lowest version comparator has an operator and our version
-        // is less than it then it isn't higher than the range
+    if (typeof version !== 'string') {
+      return null
+    }
 
+    options = options || {};
 
-        if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
-          return false;
-        } else if (low.operator === ecomp && ltfn(version, low.semver)) {
-          return false;
+    var match = null;
+    if (!options.rtl) {
+      match = version.match(re[t.COERCE]);
+    } else {
+      // Find the right-most coercible string that does not share
+      // a terminus with a more left-ward coercible string.
+      // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
+      //
+      // Walk through the string checking with a /g regexp
+      // Manually set the index so as to pick up overlapping matches.
+      // Stop when we get a match that ends at the string end, since no
+      // coercible string can be more right-ward without the same terminus.
+      var next;
+      while ((next = re[t.COERCERTL].exec(version)) &&
+        (!match || match.index + match[0].length !== version.length)
+      ) {
+        if (!match ||
+            next.index + next[0].length !== match.index + match[0].length) {
+          match = next;
         }
+        re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
       }
-
-      return true;
-    }
-
-    exports.prerelease = prerelease;
-
-    function prerelease(version, options) {
-      var parsed = parse(version, options);
-      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+      // leave it in a clean state
+      re[t.COERCERTL].lastIndex = -1;
     }
 
-    exports.intersects = intersects;
-
-    function intersects(r1, r2, options) {
-      r1 = new Range(r1, options);
-      r2 = new Range(r2, options);
-      return r1.intersects(r2);
+    if (match === null) {
+      return null
     }
 
-    exports.coerce = coerce;
-
-    function coerce(version, options) {
-      if (version instanceof SemVer) {
-        return version;
-      }
-
-      if (typeof version === 'number') {
-        version = String(version);
-      }
-
-      if (typeof version !== 'string') {
-        return null;
-      }
-
-      options = options || {};
-      var match = null;
-
-      if (!options.rtl) {
-        match = version.match(re[t.COERCE]);
-      } else {
-        // Find the right-most coercible string that does not share
-        // a terminus with a more left-ward coercible string.
-        // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
-        //
-        // Walk through the string checking with a /g regexp
-        // Manually set the index so as to pick up overlapping matches.
-        // Stop when we get a match that ends at the string end, since no
-        // coercible string can be more right-ward without the same terminus.
-        var next;
-
-        while ((next = re[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {
-          if (!match || next.index + next[0].length !== match.index + match[0].length) {
-            match = next;
-          }
-
-          re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
-        } // leave it in a clean state
-
-
-        re[t.COERCERTL].lastIndex = -1;
-      }
-
-      if (match === null) {
-        return null;
-      }
-
-      return parse(match[2] + '.' + (match[3] || '0') + '.' + (match[4] || '0'), options);
-    }
-  })(semver, semver.exports);
+    return parse(match[2] +
+      '.' + (match[3] || '0') +
+      '.' + (match[4] || '0'), options)
+  }
+  }(semver, semver.exports));
 
   const LOADED = {};
   /**
@@ -29354,6 +29906,22 @@
           if (!fieldName) {
             throw new Error("Field identifier must be provided");
           }
+          /**
+           * @typedef { 'ltr' | 'rtl' } Direction
+           */
+
+          /**
+           * @typedef { 'vertical' | 'horizontal' } ListLayout
+           */
+
+          /**
+           * @typedef { 'none' | 'value' | 'percent' | 'relative' } FrequencyMode
+           */
+
+          /**
+           * @typedef { false | true | 'toggle' } SearchMode
+           */
+
           /**
            * @typedef {function(function)} ReceiverFunction A callback function which receives another function as input.
            */
@@ -29373,9 +29941,13 @@
              * @param {HTMLElement} element
              * @param {object=} options Settings for the embedded listbox
              * @param {string=} options.title Custom title, defaults to fieldname
-             * @param {string=} [options.direction=ltr] Direction setting ltr|rtl.
-             * @param {string=} [options.listLayout=vertical] Layout direction vertical|horizontal
-             * @param {boolean=} [options.search=true] Show the search bar
+             * @param {Direction=} [options.direction=ltr] Direction setting ltr|rtl.
+             * @param {ListLayout=} [options.listLayout=vertical] Layout direction vertical|horizontal
+             * @param {FrequencyMode=} [options.frequencyMode=none] Show frequency none|value|percent|relative
+             * @param {boolean=} [options.histogram=false] Show histogram bar
+             * @param {SearchMode=} [options.search=true] Show the search bar permanently or using the toggle button: false|true|toggle|toggleShow
+             * @param {boolean=} [options.focusSearch=false] Initialize the Listbox with the search input focused. Only applicable when
+             *   search is true, since toggling will always focus the search input on show.
              * @param {boolean=} [options.toolbar=true] Show the toolbar
              * @param {boolean=} [options.checkboxes=false] Show values as checkboxes instead of as fields
              * @param {boolean=} [options.rangeSelect=true] Enable range selection
@@ -29384,6 +29956,7 @@
              * @param {object=} [options.properties={}] Properties object to extend default properties with
              * @param {object} [options.sessionModel] Use a custom sessionModel.
              * @param {object} [options.selectionsApi] Use a custom selectionsApi to customize how values are selected.
+             * @param {function():boolean} [options.selectDisabled=] Define a function which tells when selections are disabled (true) or enabled (false). By default, always returns false.
              * @param {ReceiverFunction} [options.update] A function which receives an update function which upon call will trigger a data fetch.
              * @since 1.1.0
              * @instance