https://www.gainrep.com/scripts/choices/choices.js

1/*! choices.js v9.0.1 | © 2019 Josh Johnson | https://github.com/jshjohnson/Choices#readme */
2(function webpackUniversalModuleDefinition(root, factory) {
3	if(typeof exports === 'object' && typeof module === 'object')
4		module.exports = factory();
5	else if(typeof define === 'function' && define.amd)
6		define([], factory);
7	else if(typeof exports === 'object')
8		exports["Choices"] = factory();
9	else
10		root["Choices"] = factory();
11})(window, function() {
12return /******/ (function(modules) { // webpackBootstrap
13/******/ 	// The module cache
14/******/ 	var installedModules = {};
15/******/
16/******/ 	// The require function
17/******/ 	function __webpack_require__(moduleId) {
18/******/
19/******/ 		// Check if module is in cache
20/******/ 		if(installedModules[moduleId]) {
21/******/ 			return installedModules[moduleId].exports;
22/******/ 		}
23/******/ 		// Create a new module (and put it into the cache)
24/******/ 		var module = installedModules[moduleId] = {
25/******/ 			i: moduleId,
26/******/ 			l: false,
27/******/ 			exports: {}
28/******/ 		};
29/******/
30/******/ 		// Execute the module function
31/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
32/******/
33/******/ 		// Flag the module as loaded
34/******/ 		module.l = true;
35/******/
36/******/ 		// Return the exports of the module
37/******/ 		return module.exports;
38/******/ 	}
39/******/
40/******/
41/******/ 	// expose the modules object (__webpack_modules__)
42/******/ 	__webpack_require__.m = modules;
43/******/
44/******/ 	// expose the module cache
45/******/ 	__webpack_require__.c = installedModules;
46/******/
47/******/ 	// define getter function for harmony exports
48/******/ 	__webpack_require__.d = function(exports, name, getter) {
49/******/ 		if(!__webpack_require__.o(exports, name)) {
50/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
51/******/ 		}
52/******/ 	};
53/******/
54/******/ 	// define __esModule on exports
55/******/ 	__webpack_require__.r = function(exports) {
56/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
57/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
58/******/ 		}
59/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
60/******/ 	};
61/******/
62/******/ 	// create a fake namespace object
63/******/ 	// mode & 1: value is a module id, require it
64/******/ 	// mode & 2: merge all properties of value into the ns
65/******/ 	// mode & 4: return value when already ns object
66/******/ 	// mode & 8|1: behave like require
67/******/ 	__webpack_require__.t = function(value, mode) {
68/******/ 		if(mode & 1) value = __webpack_require__(value);
69/******/ 		if(mode & 8) return value;
70/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
71/******/ 		var ns = Object.create(null);
72/******/ 		__webpack_require__.r(ns);
73/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
74/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
75/******/ 		return ns;
76/******/ 	};
77/******/
78/******/ 	// getDefaultExport function for compatibility with non-harmony modules
79/******/ 	__webpack_require__.n = function(module) {
80/******/ 		var getter = module && module.__esModule ?
81/******/ 			function getDefault() { return module['default']; } :
82/******/ 			function getModuleExports() { return module; };
83/******/ 		__webpack_require__.d(getter, 'a', getter);
84/******/ 		return getter;
85/******/ 	};
86/******/
87/******/ 	// Object.prototype.hasOwnProperty.call
88/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
89/******/
90/******/ 	// __webpack_public_path__
91/******/ 	__webpack_require__.p = "/public/assets/scripts/";
92/******/
93/******/
94/******/ 	// Load entry module and return exports
95/******/ 	return __webpack_require__(__webpack_require__.s = 7);
96/******/ })
97/************************************************************************/
98/******/ ([
99/* 0 */
100/***/ (function(module, exports, __webpack_require__) {
101
102"use strict";
103
104
105Object.defineProperty(exports, "__esModule", {
106  value: true
107});
108
109var utils_1 = __webpack_require__(1);
110
111exports.DEFAULT_CLASSNAMES = {
112  containerOuter: 'choices',
113  containerInner: 'choices__inner',
114  input: 'choices__input',
115  inputCloned: 'choices__input--cloned',
116  list: 'choices__list',
117  listItems: 'choices__list--multiple',
118  listSingle: 'choices__list--single',
119  listDropdown: 'choices__list--dropdown',
120  item: 'choices__item',
121  itemSelectable: 'choices__item--selectable',
122  itemDisabled: 'choices__item--disabled',
123  itemChoice: 'choices__item--choice',
124  placeholder: 'choices__placeholder',
125  group: 'choices__group',
126  groupHeading: 'choices__heading',
127  button: 'choices__button',
128  activeState: 'is-active',
129  focusState: 'is-focused',
130  openState: 'is-open',
131  disabledState: 'is-disabled',
132  highlightedState: 'is-highlighted',
133  selectedState: 'is-selected',
134  flippedState: 'is-flipped',
135  loadingState: 'is-loading',
136  noResults: 'has-no-results',
137  noChoices: 'has-no-choices'
138};
139exports.DEFAULT_CONFIG = {
140  items: [],
141  choices: [],
142  silent: false,
143  renderChoiceLimit: -1,
144  maxItemCount: -1,
145  addItems: true,
146  addItemFilter: null,
147  removeItems: true,

480  var proto = obj;
481
482  while (Object.getPrototypeOf(proto) !== null) {
483    proto = Object.getPrototypeOf(proto);
484  }
485
486  return Object.getPrototypeOf(obj) === proto;
487}
488
489/**
490 * Creates a Redux store that holds the state tree.
491 * The only way to change the data in the store is to call `dispatch()` on it.
492 *
493 * There should only be a single store in your app. To specify how different
494 * parts of the state tree respond to actions, you may combine several reducers
495 * into a single reducer function by using `combineReducers`.
496 *
497 * @param {Function} reducer A function that returns the next state tree, given
498 * the current state tree and the action to handle.
499 *
500 * @param {any} [preloadedState] The initial state. You may optionally specify it
501 * to hydrate the state from the server in universal apps, or to restore a
502 * previously serialized user session.
503 * If you use `combineReducers` to produce the root reducer function, this must be
504 * an object with the same shape as `combineReducers` keys.
505 *
506 * @param {Function} [enhancer] The store enhancer. You may optionally specify it
507 * to enhance the store with third-party capabilities such as middleware,
508 * time travel, persistence, etc. The only store enhancer that ships with Redux
509 * is `applyMiddleware()`.
510 *
511 * @returns {Store} A Redux store that lets you read the state, dispatch actions
512 * and subscribe to changes.
513 */
514
515function createStore(reducer, preloadedState, enhancer) {
516  var _ref2;
517
518  if (typeof preloadedState === 'function' && typeof enhancer === 'function' || typeof enhancer === 'function' && typeof arguments[3] === 'function') {
519    throw new Error('It looks like you are passing several store enhancers to ' + 'createStore(). This is not supported. Instead, compose them ' + 'together to a single function.');
520  }
521
522  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
523    enhancer = preloadedState;
524    preloadedState = undefined;
525  }
526
527  if (typeof enhancer !== 'undefined') {
528    if (typeof enhancer !== 'function') {
529      throw new Error('Expected the enhancer to be a function.');
530    }
531
532    return enhancer(createStore)(reducer, preloadedState);
533  }
534
535  if (typeof reducer !== 'function') {
536    throw new Error('Expected the reducer to be a function.');
537  }
538
539  var currentReducer = reducer;
540  var currentState = preloadedState;
541  var currentListeners = [];
542  var nextListeners = currentListeners;
543  var isDispatching = false;
544  /**
545   * This makes a shallow copy of currentListeners so we can use
546   * nextListeners as a temporary list while dispatching.
547   *
548   * This prevents any bugs around consumers calling
549   * subscribe/unsubscribe in the middle of a dispatch.
550   */
551
552  function ensureCanMutateNextListeners() {
553    if (nextListeners === currentListeners) {
554      nextListeners = currentListeners.slice();
555    }
556  }
557  /**
558   * Reads the state tree managed by the store.
559   *
560   * @returns {any} The current state tree of your application.
561   */
562
563
564  function getState() {
565    if (isDispatching) {
566      throw new Error('You may not call store.getState() while the reducer is executing. ' + 'The reducer has already received the state as an argument. ' + 'Pass it down from the top reducer instead of reading it from the store.');
567    }
568
569    return currentState;
570  }
571  /**
572   * Adds a change listener. It will be called any time an action is dispatched,
573   * and some part of the state tree may potentially have changed. You may then
574   * call `getState()` to read the current state tree inside the callback.
575   *
576   * You may call `dispatch()` from a change listener, with the following
577   * caveats:
578   *
579   * 1. The subscriptions are snapshotted just before every `dispatch()` call.
580   * If you subscribe or unsubscribe while the listeners are being invoked, this
581   * will not have any effect on the `dispatch()` that is currently in progress.
582   * However, the next `dispatch()` call, whether nested or not, will use a more
583   * recent snapshot of the subscription list.
584   *
585   * 2. The listener should not expect to see all state changes, as the state
586   * might have been updated multiple times during a nested `dispatch()` before
587   * the listener is called. It is, however, guaranteed that all subscribers
588   * registered before the `dispatch()` started will be called with the latest
589   * state by the time it exits.
590   *
591   * @param {Function} listener A callback to be invoked on every dispatch.
592   * @returns {Function} A function to remove this change listener.
593   */
594
595
596  function subscribe(listener) {
597    if (typeof listener !== 'function') {
598      throw new Error('Expected the listener to be a function.');
599    }
600
601    if (isDispatching) {
602      throw new Error('You may not call store.subscribe() while the reducer is executing. ' + 'If you would like to be notified after the store has been updated, subscribe from a ' + 'component and invoke store.getState() in the callback to access the latest state. ' + 'See https://redux.js.org/api-reference/store#subscribe(listener) for more details.');
603    }
604
605    var isSubscribed = true;
606    ensureCanMutateNextListeners();
607    nextListeners.push(listener);
608    return function unsubscribe() {
609      if (!isSubscribed) {
610        return;
611      }
612
613      if (isDispatching) {
614        throw new Error('You may not unsubscribe from a store listener while the reducer is executing. ' + 'See https://redux.js.org/api-reference/store#subscribe(listener) for more details.');
615      }
616
617      isSubscribed = false;
618      ensureCanMutateNextListeners();
619      var index = nextListeners.indexOf(listener);
620      nextListeners.splice(index, 1);
621    };
622  }
623  /**
624   * Dispatches an action. It is the only way to trigger a state change.
625   *
626   * The `reducer` function, used to create the store, will be called with the
627   * current state tree and the given `action`. Its return value will
628   * be considered the **next** state of the tree, and the change listeners
629   * will be notified.
630   *
631   * The base implementation only supports plain object actions. If you want to
632   * dispatch a Promise, an Observable, a thunk, or something else, you need to
633   * wrap your store creating function into the corresponding middleware. For
634   * example, see the documentation for the `redux-thunk` package. Even the
635   * middleware will eventually dispatch plain object actions using this method.
636   *
637   * @param {Object} action A plain object representing “what changed”. It is
638   * a good idea to keep actions serializable so you can record and replay user
639   * sessions, or use the time travelling `redux-devtools`. An action must have
640   * a `type` property which may not be `undefined`. It is a good idea to use
641   * string constants for action types.
642   *
643   * @returns {Object} For convenience, the same action object you dispatched.
644   *
645   * Note that, if you use a custom middleware, it may wrap `dispatch()` to
646   * return something else (for example, a Promise you can await).
647   */
648
649
650  function dispatch(action) {
651    if (!isPlainObject(action)) {
652      throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');
653    }
654
655    if (typeof action.type === 'undefined') {
656      throw new Error('Actions may not have an undefined "type" property. ' + 'Have you misspelled a constant?');
657    }
658
659    if (isDispatching) {
660      throw new Error('Reducers may not dispatch actions.');
661    }
662
663    try {
664      isDispatching = true;
665      currentState = currentReducer(currentState, action);
666    } finally {
667      isDispatching = false;
668    }
669
670    var listeners = currentListeners = nextListeners;
671
672    for (var i = 0; i < listeners.length; i++) {
673      var listener = listeners[i];
674      listener();
675    }
676
677    return action;
678  }
679  /**
680   * Replaces the reducer currently used by the store to calculate the state.
681   *
682   * You might need this if your app implements code splitting and you want to
683   * load some of the reducers dynamically. You might also need this if you
684   * implement a hot reloading mechanism for Redux.
685   *
686   * @param {Function} nextReducer The reducer for the store to use instead.
687   * @returns {void}
688   */
689
690
691  function replaceReducer(nextReducer) {
692    if (typeof nextReducer !== 'function') {
693      throw new Error('Expected the nextReducer to be a function.');
694    }
695
696    currentReducer = nextReducer; // This action has a similiar effect to ActionTypes.INIT.
697    // Any reducers that existed in both the new and old rootReducer
698    // will receive the previous state. This effectively populates
699    // the new state tree with any relevant data from the old one.
700
701    dispatch({
702      type: ActionTypes.REPLACE
703    });
704  }
705  /**
706   * Interoperability point for observable/reactive libraries.
707   * @returns {observable} A minimal observable of state changes.
708   * For more information, see the observable proposal:
709   * https://github.com/tc39/proposal-observable
710   */
711
712
713  function observable() {
714    var _ref;
715
716    var outerSubscribe = subscribe;
717    return _ref = {
718      /**
719       * The minimal observable subscription method.
720       * @param {Object} observer Any object that can be used as an observer.
721       * The observer object should have a `next` method.
722       * @returns {subscription} An object with an `unsubscribe` method that can
723       * be used to unsubscribe the observable from the store, and prevent further
724       * emission of values from the observable.
725       */
726      subscribe: function subscribe(observer) {
727        if (typeof observer !== 'object' || observer === null) {
728          throw new TypeError('Expected the observer to be an object.');
729        }
730
731        function observeState() {
732          if (observer.next) {
733            observer.next(getState());
734          }
735        }
736
737        observeState();
738        var unsubscribe = outerSubscribe(observeState);
739        return {
740          unsubscribe: unsubscribe
741        };
742      }
743    }

1444    this._highlightPosition = 0;
1445    this._wasTap = true;
1446    this._placeholderValue = this._generatePlaceholderValue();
1447    this._baseId = utils_1.generateId(this.passedElement.element, 'choices-');
1448    /**
1449     * setting direction in cases where it's explicitly set on passedElement
1450     * or when calculated direction is different from the document
1451     */
1452
1453    this._direction = this.passedElement.dir;
1454
1455    if (!this._direction) {
1456      var elementDirection = window.getComputedStyle(this.passedElement.element).direction;
1457      var documentDirection = window.getComputedStyle(document.documentElement).direction;
1458
1459      if (elementDirection !== documentDirection) {
1460        this._direction = elementDirection;
1461      }
1462    }
1463
1464    this._idNames = {
1465      itemChoice: 'item-choice'
1466    };
1467
1468    if (this._isSelectElement) {
1469      // Assign preset groups from passed element
1470      this._presetGroups = this.passedElement.optionGroups; // Assign preset options from passed element
1471
1472      this._presetOptions = this.passedElement.options;
1473    } // Assign preset choices from passed object
1474
1475
1476    this._presetChoices = this.config.choices; // Assign preset items from passed object first
1477
1478    this._presetItems = this.config.items; // Add any values passed from attribute
1479
1480    if (this.passedElement.value && this._isTextElement) {
1481      var splitValues = this.passedElement.value.split(this.config.delimiter);
1482      this._presetItems = this._presetItems.concat(splitValues);
1483    } // Create array of choices from option elements
1484
1485
1486    if (this.passedElement.options) {
1487      this.passedElement.options.forEach(function (option) {
1488        _this._presetChoices.push({
1489          value: option.value,
1490          label: option.innerHTML,
1491          selected: !!option.selected,
1492          disabled: option.disabled || option.parentNode.disabled,
1493          placeholder: option.value === '' || option.hasAttribute('placeholder'),
1494          customProperties: option.dataset['custom-properties']
1495        });
1496      });
1497    }
1498
1499    this._render = this._render.bind(this);
1500    this._onFocus = this._onFocus.bind(this);
1501    this._onBlur = this._onBlur.bind(this);
1502    this._onKeyUp = this._onKeyUp.bind(this);
1503    this._onKeyDown = this._onKeyDown.bind(this);
1504    this._onClick = this._onClick.bind(this);
1505    this._onTouchMove = this._onTouchMove.bind(this);
1506    this._onTouchEnd = this._onTouchEnd.bind(this);
1507    this._onMouseDown = this._onMouseDown.bind(this);
1508    this._onMouseOver = this._onMouseOver.bind(this);
1509    this._onFormReset = this._onFormReset.bind(this);
1510    this._onSelectKey = this._onSelectKey.bind(this);
1511    this._onEnterKey = this._onEnterKey.bind(this);
1512    this._onEscapeKey = this._onEscapeKey.bind(this);
1513    this._onDirectionKey = this._onDirectionKey.bind(this);
1514    this._onDeleteKey = this._onDeleteKey.bind(this); // If element has already been initialised with Choices, fail silently
1515
1516    if (this.passedElement.isActive) {
1517      if (!this.config.silent) {
1518        console.warn('Trying to initialise Choices on element already initialised', {
1519          element: element
1520        });
1521      }
1522
1523      this.initialised = true;
1524      return;
1525    } // Let's go
1526
1527
1528    this.init();
1529  }
1530
1531  Object.defineProperty(Choices, "defaults", {
1532    get: function get() {
1533      return Object.preventExtensions({
1534        get options() {
1535          return USER_DEFAULTS;
1536        },
1537
1538        get templates() {
1539          return templates_1.default;
1540        }
1541
1542      });
1543    },
1544    enumerable: true,
1545    configurable: true
1546  });
1547
1548  Choices.prototype.init = function () {
1549    if (this.initialised) {
1550      return;
1551    }
1552
1553    this._createTemplates();
1554
1555    this._createElements();
1556
1557    this._createStructure();
1558
1559    this._store.subscribe(this._render);
1560
1561    this._render();
1562
1563    this._addEventListeners();
1564
1565    var shouldDisable = !this.config.addItems || this.passedElement.element.hasAttribute('disabled');
1566
1567    if (shouldDisable) {
1568      this.disable();
1569    }
1570
1571    this.initialised = true;
1572    var callbackOnInit = this.config.callbackOnInit; // Run callback if it is a function
1573
1574    if (callbackOnInit && typeof callbackOnInit === 'function') {
1575      callbackOnInit.call(this);
1576    }
1577  };
1578
1579  Choices.prototype.destroy = function () {
1580    if (!this.initialised) {
1581      return;
1582    }
1583
1584    this._removeEventListeners();
1585
1586    this.passedElement.reveal();
1587    this.containerOuter.unwrap(this.passedElement.element);
1588    this.clearStore();
1589
1590    if (this._isSelectElement) {
1591      this.passedElement.options = this._presetOptions;
1592    }
1593
1594    this._templates = templates_1.default;
1595    this.initialised = false;
1596  };
1597
1598  Choices.prototype.enable = function () {
1599    if (this.passedElement.isDisabled) {
1600      this.passedElement.enable();
1601    }
1602
1603    if (this.containerOuter.isDisabled) {
1604      this._addEventListeners();
1605
1606      this.input.enable();
1607      this.containerOuter.enable();
1608    }
1609
1610    return this;
1611  };
1612
1613  Choices.prototype.disable = function () {
1614    if (!this.passedElement.isDisabled) {
1615      this.passedElement.disable();
1616    }
1617
1618    if (!this.containerOuter.isDisabled) {
1619      this._removeEventListeners();
1620
1621      this.input.disable();
1622      this.containerOuter.disable();
1623    }
1624
1625    return this;
1626  };
1627
1628  Choices.prototype.highlightItem = function (item, runEvent) {
1629    if (runEvent === void 0) {
1630      runEvent = true;
1631    }
1632
1633    if (!item || !item.id) {
1634      return this;
1635    }
1636
1637    var id = item.id,
1638        _a = item.groupId,
1639        groupId = _a === void 0 ? -1 : _a,
1640        _b = item.value,
1641        value = _b === void 0 ? '' : _b,
1642        _c = item.label,
1643        label = _c === void 0 ? '' : _c;
1644    var group = groupId >= 0 ? this._store.getGroupById(groupId) : null;
1645
1646    this._store.dispatch(items_1.highlightItem(id, true));
1647
1648    if (runEvent) {
1649      this.passedElement.triggerEvent(constants_1.EVENTS.highlightItem, {
1650        id: id,
1651        value: value,
1652        label: label,
1653        groupValue: group && group.value ? group.value : null
1654      });
1655    }
1656
1657    return this;
1658  };
1659
1660  Choices.prototype.unhighlightItem = function (item) {
1661    if (!item || !item.id) {
1662      return this;
1663    }
1664
1665    var id = item.id,
1666        _a = item.groupId,
1667        groupId = _a === void 0 ? -1 : _a,
1668        _b = item.value,
1669        value = _b === void 0 ? '' : _b,
1670        _c = item.label,
1671        label = _c === void 0 ? '' : _c;
1672    var group = groupId >= 0 ? this._store.getGroupById(groupId) : null;
1673
1674    this._store.dispatch(items_1.highlightItem(id, false));
1675
1676    this.passedElement.triggerEvent(constants_1.EVENTS.highlightItem, {
1677      id: id,
1678      value: value,
1679      label: label,
1680      groupValue: group && group.value ? group.value : null
1681    });
1682    return this;
1683  };
1684
1685  Choices.prototype.highlightAll = function () {
1686    var _this = this;
1687
1688    this._store.items.forEach(function (item) {
1689      return _this.highlightItem(item);
1690    });
1691
1692    return this;
1693  };
1694
1695  Choices.prototype.unhighlightAll = function () {
1696    var _this = this;
1697
1698    this._store.items.forEach(function (item) {
1699      return _this.unhighlightItem(item);
1700    });
1701
1702    return this;
1703  };
1704
1705  Choices.prototype.removeActiveItemsByValue = function (value) {
1706    var _this = this;
1707
1708    this._store.activeItems.filter(function (item) {
1709      return item.value === value;
1710    }).forEach(function (item) {
1711      return _this._removeItem(item);
1712    });
1713
1714    return this;
1715  };
1716
1717  Choices.prototype.removeActiveItems = function (excludedId) {
1718    var _this = this;
1719
1720    this._store.activeItems.filter(function (_a) {
1721      var id = _a.id;
1722      return id !== excludedId;
1723    }).forEach(function (item) {
1724      return _this._removeItem(item);
1725    });
1726
1727    return this;
1728  };
1729
1730  Choices.prototype.removeHighlightedItems = function (runEvent) {
1731    var _this = this;
1732
1733    if (runEvent === void 0) {
1734      runEvent = false;
1735    }
1736
1737    this._store.highlightedActiveItems.forEach(function (item) {
1738      _this._removeItem(item); // If this action was performed by the user
1739      // trigger the event
1740
1741
1742      if (runEvent) {
1743        _this._triggerChange(item.value);
1744      }
1745    });
1746
1747    return this;
1748  };
1749
1750  Choices.prototype.showDropdown = function (preventInputFocus) {
1751    var _this = this;
1752
1753    if (this.dropdown.isActive) {
1754      return this;
1755    }
1756
1757    requestAnimationFrame(function () {
1758      _this.dropdown.show();
1759
1760      _this.containerOuter.open(_this.dropdown.distanceFromTopWindow);
1761
1762      if (!preventInputFocus && _this._canSearch) {
1763        _this.input.focus();
1764      }
1765
1766      _this.passedElement.triggerEvent(constants_1.EVENTS.showDropdown, {});
1767    });
1768    return this;
1769  };
1770
1771  Choices.prototype.hideDropdown = function (preventInputBlur) {
1772    var _this = this;
1773
1774    if (!this.dropdown.isActive) {
1775      return this;
1776    }
1777
1778    requestAnimationFrame(function () {
1779      _this.dropdown.hide();
1780
1781      _this.containerOuter.close();
1782
1783      if (!preventInputBlur && _this._canSearch) {
1784        _this.input.removeActiveDescendant();
1785
1786        _this.input.blur();
1787      }
1788
1789      _this.passedElement.triggerEvent(constants_1.EVENTS.hideDropdown, {});
1790    });
1791    return this;
1792  };
1793
1794  Choices.prototype.getValue = function (valueOnly) {
1795    if (valueOnly === void 0) {
1796      valueOnly = false;
1797    }
1798
1799    var values = this._store.activeItems.reduce(function (selectedItems, item) {
1800      var itemValue = valueOnly ? item.value : item;
1801      selectedItems.push(itemValue);
1802      return selectedItems;
1803    }, []);
1804
1805    return this._isSelectOneElement ? values[0] : values;
1806  };
1807
1808  Choices.prototype.setValue = function (items) {
1809    var _this = this;
1810
1811    if (!this.initialised) {
1812      return this;
1813    }
1814
1815    items.forEach(function (value) {
1816      return _this._setChoiceOrItem(value);
1817    });
1818    return this;
1819  };
1820
1821  Choices.prototype.setChoiceByValue = function (value) {
1822    var _this = this;
1823
1824    if (!this.initialised || this._isTextElement) {
1825      return this;
1826    } // If only one value has been passed, convert to array
1827
1828
1829    var choiceValue = Array.isArray(value) ? value : [value]; // Loop through each value and
1830
1831    choiceValue.forEach(function (val) {
1832      return _this._findAndSelectChoiceByValue(val);
1833    });
1834    return this;
1835  };
1836  /**
1837   * Set choices of select input via an array of objects (or function that returns array of object or promise of it),
1838   * a value field name and a label field name.
1839   * This behaves the same as passing items via the choices option but can be called after initialising Choices.
1840   * This can also be used to add groups of choices (see example 2); Optionally pass a true `replaceChoices` value to remove any existing choices.
1841   * Optionally pass a `customProperties` object to add additional data to your choices (useful when searching/filtering etc).
1842   *
1843   * **Input types affected:** select-one, select-multiple
1844   *
1845   * @example
1846   * ```js
1847   * const example = new Choices(element);
1848   *
1849   * example.setChoices([
1850   *   {value: 'One', label: 'Label One', disabled: true},
1851   *   {value: 'Two', label: 'Label Two', selected: true},
1852   *   {value: 'Three', label: 'Label Three'},
1853   * ], 'value', 'label', false);
1854   * ```
1855   *
1856   * @example
1857   * ```js
1858   * const example = new Choices(element);
1859   *
1860   * example.setChoices(async () => {
1861   *   try {
1862   *      const items = await fetch('/items');
1863   *      return items.json()
1864   *   } catch(err) {
1865   *      console.error(err)
1866   *   }
1867   * });
1868   * ```
1869   *
1870   * @example
1871   * ```js
1872   * const example = new Choices(element);
1873   *
1874   * example.setChoices([{
1875   *   label: 'Group one',
1876   *   id: 1,
1877   *   disabled: false,
1878   *   choices: [
1879   *     {value: 'Child One', label: 'Child One', selected: true},
1880   *     {value: 'Child Two', label: 'Child Two',  disabled: true},
1881   *     {value: 'Child Three', label: 'Child Three'},
1882   *   ]
1883   * },
1884   * {

2026
2027      this._store.dispatch(choices_1.activateChoices(true));
2028    }
2029
2030    return this;
2031  };
2032
2033  Choices.prototype._render = function () {
2034    if (this._store.isLoading()) {
2035      return;
2036    }
2037
2038    this._currentState = this._store.state;
2039    var stateChanged = this._currentState.choices !== this._prevState.choices || this._currentState.groups !== this._prevState.groups || this._currentState.items !== this._prevState.items;
2040    var shouldRenderChoices = this._isSelectElement;
2041    var shouldRenderItems = this._currentState.items !== this._prevState.items;
2042
2043    if (!stateChanged) {
2044      return;
2045    }
2046
2047    if (shouldRenderChoices) {
2048      this._renderChoices();
2049    }
2050
2051    if (shouldRenderItems) {
2052      this._renderItems();
2053    }
2054
2055    this._prevState = this._currentState;
2056  };
2057
2058  Choices.prototype._renderChoices = function () {
2059    var _this = this;
2060
2061    var _a = this._store,
2062        activeGroups = _a.activeGroups,
2063        activeChoices = _a.activeChoices;
2064    var choiceListFragment = document.createDocumentFragment();
2065    this.choiceList.clear();
2066
2067    if (this.config.resetScrollPosition) {
2068      requestAnimationFrame(function () {
2069        return _this.choiceList.scrollToTop();
2070      });
2071    } // If we have grouped options
2072
2073
2074    if (activeGroups.length >= 1 && !this._isSearching) {
2075      // If we have a placeholder choice along with groups
2076      var activePlaceholders = activeChoices.filter(function (activeChoice) {
2077        return activeChoice.placeholder === true && activeChoice.groupId === -1;
2078      });
2079
2080      if (activePlaceholders.length >= 1) {
2081        choiceListFragment = this._createChoicesFragment(activePlaceholders, choiceListFragment);
2082      }
2083
2084      choiceListFragment = this._createGroupsFragment(activeGroups, activeChoices, choiceListFragment);
2085    } else if (activeChoices.length >= 1) {
2086      choiceListFragment = this._createChoicesFragment(activeChoices, choiceListFragment);
2087    } // If we have choices to show
2088
2089
2090    if (choiceListFragment.childNodes && choiceListFragment.childNodes.length > 0) {
2091      var activeItems = this._store.activeItems;
2092
2093      var canAddItem = this._canAddItem(activeItems, this.input.value); // ...and we can select them
2094
2095
2096      if (canAddItem.response) {
2097        // ...append them and highlight the first choice
2098        this.choiceList.append(choiceListFragment);
2099
2100        this._highlightChoice();
2101      } else {
2102        var notice = this._getTemplate('notice', canAddItem.notice);
2103
2104        this.choiceList.append(notice);
2105      }
2106    } else {
2107      // Otherwise show a notice
2108      var dropdownItem = void 0;
2109      var notice = void 0;
2110
2111      if (this._isSearching) {
2112        notice = typeof this.config.noResultsText === 'function' ? this.config.noResultsText() : this.config.noResultsText;
2113        dropdownItem = this._getTemplate('notice', notice, 'no-results');
2114      } else {
2115        notice = typeof this.config.noChoicesText === 'function' ? this.config.noChoicesText() : this.config.noChoicesText;
2116        dropdownItem = this._getTemplate('notice', notice, 'no-choices');
2117      }
2118
2119      this.choiceList.append(dropdownItem);
2120    }
2121  };
2122
2123  Choices.prototype._renderItems = function () {
2124    var activeItems = this._store.activeItems || [];
2125    this.itemList.clear(); // Create a fragment to store our list items
2126    // (so we don't have to update the DOM for each item)
2127
2128    var itemListFragment = this._createItemsFragment(activeItems); // If we have items to add, append them
2129
2130
2131    if (itemListFragment.childNodes) {
2132      this.itemList.append(itemListFragment);
2133    }
2134  };
2135
2136  Choices.prototype._createGroupsFragment = function (groups, choices, fragment) {
2137    var _this = this;
2138
2139    if (fragment === void 0) {
2140      fragment = document.createDocumentFragment();
2141    }
2142
2143    var getGroupChoices = function getGroupChoices(group) {
2144      return choices.filter(function (choice) {
2145        if (_this._isSelectOneElement) {
2146          return choice.groupId === group.id;
2147        }
2148
2149        return choice.groupId === group.id && (_this.config.renderSelectedChoices === 'always' || !choice.selected);
2150      });
2151    }; // If sorting is enabled, filter groups
2152
2153
2154    if (this.config.shouldSort) {
2155      groups.sort(this.config.sorter);
2156    }
2157
2158    groups.forEach(function (group) {
2159      var groupChoices = getGroupChoices(group);
2160
2161      if (groupChoices.length >= 1) {
2162        var dropdownGroup = _this._getTemplate('choiceGroup', group);
2163
2164        fragment.appendChild(dropdownGroup);
2165
2166        _this._createChoicesFragment(groupChoices, fragment, true);
2167      }
2168    });
2169    return fragment;
2170  };
2171
2172  Choices.prototype._createChoicesFragment = function (choices, fragment, withinGroup) {
2173    var _this = this;
2174
2175    if (fragment === void 0) {
2176      fragment = document.createDocumentFragment();
2177    }
2178
2179    if (withinGroup === void 0) {
2180      withinGroup = false;
2181    } // Create a fragment to store our list items (so we don't have to update the DOM for each item)
2182
2183
2184    var _a = this.config,
2185        renderSelectedChoices = _a.renderSelectedChoices,
2186        searchResultLimit = _a.searchResultLimit,
2187        renderChoiceLimit = _a.renderChoiceLimit;
2188    var filter = this._isSearching ? utils_1.sortByScore : this.config.sorter;
2189
2190    var appendChoice = function appendChoice(choice) {
2191      var shouldRender = renderSelectedChoices === 'auto' ? _this._isSelectOneElement || !choice.selected : true;
2192
2193      if (shouldRender) {
2194        var dropdownItem = _this._getTemplate('choice', choice, _this.config.itemSelectText);
2195
2196        fragment.appendChild(dropdownItem);
2197      }
2198    };
2199
2200    var rendererableChoices = choices;
2201
2202    if (renderSelectedChoices === 'auto' && !this._isSelectOneElement) {
2203      rendererableChoices = choices.filter(function (choice) {
2204        return !choice.selected;
2205      });
2206    } // Split array into placeholders and "normal" choices
2207
2208
2209    var _b = rendererableChoices.reduce(function (acc, choice) {
2210      if (choice.placeholder) {
2211        acc.placeholderChoices.push(choice);
2212      } else {
2213        acc.normalChoices.push(choice);
2214      }
2215
2216      return acc;
2217    }, {
2218      placeholderChoices: [],
2219      normalChoices: []
2220    }),
2221        placeholderChoices = _b.placeholderChoices,
2222        normalChoices = _b.normalChoices; // If sorting is enabled or the user is searching, filter choices
2223
2224
2225    if (this.config.shouldSort || this._isSearching) {
2226      normalChoices.sort(filter);
2227    }
2228
2229    var choiceLimit = rendererableChoices.length; // Prepend placeholeder
2230
2231    var sortedChoices = this._isSelectOneElement ? __spreadArrays(placeholderChoices, normalChoices) : normalChoices;
2232
2233    if (this._isSearching) {
2234      choiceLimit = searchResultLimit;
2235    } else if (renderChoiceLimit && renderChoiceLimit > 0 && !withinGroup) {
2236      choiceLimit = renderChoiceLimit;
2237    } // Add each choice to dropdown within range
2238
2239
2240    for (var i = 0; i < choiceLimit; i += 1) {
2241      if (sortedChoices[i]) {
2242        appendChoice(sortedChoices[i]);
2243      }
2244    }
2245
2246    return fragment;
2247  };
2248
2249  Choices.prototype._createItemsFragment = function (items, fragment) {
2250    var _this = this;
2251
2252    if (fragment === void 0) {
2253      fragment = document.createDocumentFragment();
2254    } // Create fragment to add elements to
2255
2256
2257    var _a = this.config,
2258        shouldSortItems = _a.shouldSortItems,
2259        sorter = _a.sorter,
2260        removeItemButton = _a.removeItemButton; // If sorting is enabled, filter items
2261
2262    if (shouldSortItems && !this._isSelectOneElement) {
2263      items.sort(sorter);
2264    }
2265
2266    if (this._isTextElement) {
2267      // Update the value of the hidden input
2268      this.passedElement.value = items.map(function (_a) {
2269        var value = _a.value;
2270        return value;
2271      }).join(this.config.delimiter);
2272    } else {
2273      // Update the options of the hidden input
2274      this.passedElement.options = items;
2275    }
2276
2277    var addItemToFragment = function addItemToFragment(item) {
2278      // Create new list element
2279      var listItem = _this._getTemplate('item', item, removeItemButton); // Append it to list
2280
2281
2282      fragment.appendChild(listItem);
2283    }; // Add each list item to list
2284
2285
2286    items.forEach(addItemToFragment);
2287    return fragment;
2288  };
2289
2290  Choices.prototype._triggerChange = function (value) {
2291    if (value === undefined || value === null) {
2292      return;
2293    }
2294
2295    this.passedElement.triggerEvent(constants_1.EVENTS.change, {
2296      value: value
2297    });
2298  };
2299
2300  Choices.prototype._selectPlaceholderChoice = function (placeholderChoice) {
2301    this._addItem({
2302      value: placeholderChoice.value,
2303      label: placeholderChoice.label,
2304      choiceId: placeholderChoice.id,
2305      groupId: placeholderChoice.groupId,
2306      placeholder: placeholderChoice.placeholder
2307    });
2308
2309    this._triggerChange(placeholderChoice.value);
2310  };
2311
2312  Choices.prototype._handleButtonAction = function (activeItems, element) {
2313    if (!activeItems || !element || !this.config.removeItems || !this.config.removeItemButton) {
2314      return;
2315    }
2316
2317    var itemId = element.parentNode && element.parentNode.dataset.id;
2318    var itemToRemove = itemId && activeItems.find(function (item) {
2319      return item.id === parseInt(itemId, 10);
2320    });
2321
2322    if (!itemToRemove) {
2323      return;
2324    } // Remove item associated with button
2325
2326
2327    this._removeItem(itemToRemove);
2328
2329    this._triggerChange(itemToRemove.value);
2330
2331    if (this._isSelectOneElement && this._store.placeholderChoice) {
2332      this._selectPlaceholderChoice(this._store.placeholderChoice);
2333    }
2334  };
2335
2336  Choices.prototype._handleItemAction = function (activeItems, element, hasShiftKey) {
2337    var _this = this;
2338
2339    if (hasShiftKey === void 0) {
2340      hasShiftKey = false;
2341    }
2342
2343    if (!activeItems || !element || !this.config.removeItems || this._isSelectOneElement) {
2344      return;
2345    }
2346
2347    var passedId = element.dataset.id; // We only want to select one item with a click
2348    // so we deselect any items that aren't the target
2349    // unless shift is being pressed
2350
2351    activeItems.forEach(function (item) {
2352      if (item.id === parseInt("" + passedId, 10) && !item.highlighted) {
2353        _this.highlightItem(item);
2354      } else if (!hasShiftKey && item.highlighted) {
2355        _this.unhighlightItem(item);
2356      }
2357    }); // Focus input as without focus, a user cannot do anything with a
2358    // highlighted item
2359
2360    this.input.focus();
2361  };
2362
2363  Choices.prototype._handleChoiceAction = function (activeItems, element) {
2364    if (!activeItems || !element) {
2365      return;
2366    } // If we are clicking on an option
2367
2368
2369    var id = element.dataset.id;
2370
2371    var choice = id && this._store.getChoiceById(id);
2372
2373    if (!choice) {
2374      return;
2375    }
2376
2377    var passedKeyCode = activeItems[0] && activeItems[0].keyCode ? activeItems[0].keyCode : undefined;
2378    var hasActiveDropdown = this.dropdown.isActive; // Update choice keyCode
2379
2380    choice.keyCode = passedKeyCode;
2381    this.passedElement.triggerEvent(constants_1.EVENTS.choice, {
2382      choice: choice
2383    });
2384
2385    if (!choice.selected && !choice.disabled) {
2386      var canAddItem = this._canAddItem(activeItems, choice.value);
2387
2388      if (canAddItem.response) {
2389        this._addItem({
2390          value: choice.value,
2391          label: choice.label,
2392          choiceId: choice.id,
2393          groupId: choice.groupId,
2394          customProperties: choice.customProperties,
2395          placeholder: choice.placeholder,
2396          keyCode: choice.keyCode
2397        });
2398
2399        this._triggerChange(choice.value);
2400      }
2401    }
2402
2403    this.clearInput(); // We want to close the dropdown if we are dealing with a single select box
2404
2405    if (hasActiveDropdown && this._isSelectOneElement) {
2406      this.hideDropdown(true);
2407      this.containerOuter.focus();
2408    }
2409  };
2410
2411  Choices.prototype._handleBackspace = function (activeItems) {
2412    if (!this.config.removeItems || !activeItems) {
2413      return;
2414    }
2415
2416    var lastItem = activeItems[activeItems.length - 1];
2417    var hasHighlightedItems = activeItems.some(function (item) {
2418      return item.highlighted;
2419    }); // If editing the last item is allowed and there are not other selected items,
2420    // we can edit the item value. Otherwise if we can remove items, remove all selected items
2421
2422    if (this.config.editItems && !hasHighlightedItems && lastItem) {
2423      this.input.value = lastItem.value;
2424      this.input.setWidth();
2425
2426      this._removeItem(lastItem);
2427
2428      this._triggerChange(lastItem.value);
2429    } else {
2430      if (!hasHighlightedItems) {
2431        // Highlight last item if none already highlighted
2432        this.highlightItem(lastItem, false);
2433      }
2434
2435      this.removeHighlightedItems(true);
2436    }
2437  };
2438
2439  Choices.prototype._startLoading = function () {
2440    this._store.dispatch(misc_1.setIsLoading(true));
2441  };
2442
2443  Choices.prototype._stopLoading = function () {
2444    this._store.dispatch(misc_1.setIsLoading(false));
2445  };
2446
2447  Choices.prototype._handleLoadingState = function (setLoading) {
2448    if (setLoading === void 0) {
2449      setLoading = true;
2450    }
2451
2452    var placeholderItem = this.itemList.getChild("." + this.config.classNames.placeholder);
2453
2454    if (setLoading) {
2455      this.disable();
2456      this.containerOuter.addLoadingState();
2457
2458      if (this._isSelectOneElement) {
2459        if (!placeholderItem) {
2460          placeholderItem = this._getTemplate('placeholder', this.config.loadingText);
2461
2462          if (placeholderItem) {
2463            this.itemList.append(placeholderItem);
2464          }
2465        } else {
2466          placeholderItem.innerHTML = this.config.loadingText;
2467        }
2468      } else {
2469        this.input.placeholder = this.config.loadingText;
2470      }
2471    } else {
2472      this.enable();
2473      this.containerOuter.removeLoadingState();
2474
2475      if (this._isSelectOneElement) {
2476        if (placeholderItem) {
2477          placeholderItem.innerHTML = this._placeholderValue || '';
2478        }
2479      } else {
2480        this.input.placeholder = this._placeholderValue || '';
2481      }
2482    }
2483  };
2484
2485  Choices.prototype._handleSearch = function (value) {
2486    if (!value || !this.input.isFocussed) {
2487      return;
2488    }
2489
2490    var choices = this._store.choices;
2491    var _a = this.config,
2492        searchFloor = _a.searchFloor,
2493        searchChoices = _a.searchChoices;
2494    var hasUnactiveChoices = choices.some(function (option) {
2495      return !option.active;
2496    }); // Check that we have a value to search and the input was an alphanumeric character
2497
2498    if (value && value.length >= searchFloor) {
2499      var resultCount = searchChoices ? this._searchChoices(value) : 0; // Trigger search event
2500
2501      this.passedElement.triggerEvent(constants_1.EVENTS.search, {
2502        value: value,
2503        resultCount: resultCount
2504      });
2505    } else if (hasUnactiveChoices) {
2506      // Otherwise reset choices to active
2507      this._isSearching = false;
2508
2509      this._store.dispatch(choices_1.activateChoices(true));
2510    }
2511  };
2512
2513  Choices.prototype._canAddItem = function (activeItems, value) {
2514    var canAddItem = true;
2515    var notice = typeof this.config.addItemText === 'function' ? this.config.addItemText(value) : this.config.addItemText;
2516
2517    if (!this._isSelectOneElement) {
2518      var isDuplicateValue = utils_1.existsInArray(activeItems, value);
2519
2520      if (this.config.maxItemCount > 0 && this.config.maxItemCount <= activeItems.length) {
2521        // If there is a max entry limit and we have reached that limit
2522        // don't update
2523        canAddItem = false;
2524        notice = typeof this.config.maxItemText === 'function' ? this.config.maxItemText(this.config.maxItemCount) : this.config.maxItemText;
2525      }
2526
2527      if (!this.config.duplicateItemsAllowed && isDuplicateValue && canAddItem) {
2528        canAddItem = false;
2529        notice = typeof this.config.uniqueItemText === 'function' ? this.config.uniqueItemText(value) : this.config.uniqueItemText;
2530      }
2531
2532      if (this._isTextElement && this.config.addItems && canAddItem && typeof this.config.addItemFilter === 'function' && !this.config.addItemFilter(value)) {
2533        canAddItem = false;
2534        notice = typeof this.config.customAddItemText === 'function' ? this.config.customAddItemText(value) : this.config.customAddItemText;
2535      }
2536    }
2537
2538    return {
2539      response: canAddItem,
2540      notice: notice
2541    };
2542  };
2543
2544  Choices.prototype._searchChoices = function (value) {
2545    var newValue = typeof value === 'string' ? value.trim() : value;
2546    var currentValue = typeof this._currentValue === 'string' ? this._currentValue.trim() : this._currentValue;
2547
2548    if (newValue.length < 1 && newValue === currentValue + " ") {
2549      return 0;
2550    } // If new value matches the desired length and is not the same as the current value with a space
2551
2552
2553    var haystack = this._store.searchableChoices;
2554    var needle = newValue;
2555
2556    var keys = __spreadArrays(this.config.searchFields);
2557
2558    var options = Object.assign(this.config.fuseOptions, {
2559      keys: keys,
2560      includeMatches: true
2561    });
2562    var fuse = new fuse_js_1.default(haystack, options);
2563    var results = fuse.search(needle); // see https://github.com/krisk/Fuse/issues/303
2564
2565    this._currentValue = newValue;
2566    this._highlightPosition = 0;
2567    this._isSearching = true;
2568
2569    this._store.dispatch(choices_1.filterChoices(results));
2570
2571    return results.length;
2572  };
2573
2574  Choices.prototype._addEventListeners = function () {
2575    var documentElement = document.documentElement; // capture events - can cancel event processing or propagation
2576
2577    documentElement.addEventListener('touchend', this._onTouchEnd, true);
2578    this.containerOuter.element.addEventListener('keydown', this._onKeyDown, true);
2579    this.containerOuter.element.addEventListener('mousedown', this._onMouseDown, true); // passive events - doesn't call `preventDefault` or `stopPropagation`
2580
2581    documentElement.addEventListener('click', this._onClick, {
2582      passive: true
2583    });
2584    documentElement.addEventListener('touchmove', this._onTouchMove, {
2585      passive: true
2586    });
2587    this.dropdown.element.addEventListener('mouseover', this._onMouseOver, {
2588      passive: true
2589    });
2590
2591    if (this._isSelectOneElement) {
2592      this.containerOuter.element.addEventListener('focus', this._onFocus, {
2593        passive: true
2594      });
2595      this.containerOuter.element.addEventListener('blur', this._onBlur, {
2596        passive: true
2597      });
2598    }
2599
2600    this.input.element.addEventListener('keyup', this._onKeyUp, {
2601      passive: true
2602    });
2603    this.input.element.addEventListener('focus', this._onFocus, {
2604      passive: true
2605    });
2606    this.input.element.addEventListener('blur', this._onBlur, {
2607      passive: true
2608    });
2609
2610    if (this.input.element.form) {
2611      this.input.element.form.addEventListener('reset', this._onFormReset, {
2612        passive: true
2613      });
2614    }
2615
2616    this.input.addEventListeners();
2617  };
2618
2619  Choices.prototype._removeEventListeners = function () {
2620    var documentElement = document.documentElement;
2621    documentElement.removeEventListener('touchend', this._onTouchEnd, true);
2622    this.containerOuter.element.removeEventListener('keydown', this._onKeyDown, true);
2623    this.containerOuter.element.removeEventListener('mousedown', this._onMouseDown, true);
2624    documentElement.removeEventListener('click', this._onClick);
2625    documentElement.removeEventListener('touchmove', this._onTouchMove);
2626    this.dropdown.element.removeEventListener('mouseover', this._onMouseOver);
2627
2628    if (this._isSelectOneElement) {
2629      this.containerOuter.element.removeEventListener('focus', this._onFocus);
2630      this.containerOuter.element.removeEventListener('blur', this._onBlur);
2631    }
2632
2633    this.input.element.removeEventListener('keyup', this._onKeyUp);
2634    this.input.element.removeEventListener('focus', this._onFocus);
2635    this.input.element.removeEventListener('blur', this._onBlur);
2636
2637    if (this.input.element.form) {
2638      this.input.element.form.removeEventListener('reset', this._onFormReset);
2639    }
2640
2641    this.input.removeEventListeners();
2642  };
2643
2644  Choices.prototype._onKeyDown = function (event) {
2645    var keyCode = event.keyCode;
2646    var activeItems = this._store.activeItems;
2647    var hasFocusedInput = this.input.isFocussed;
2648    var hasActiveDropdown = this.dropdown.isActive;
2649    var hasItems = this.itemList.hasChildren();
2650    var keyString = String.fromCharCode(keyCode);
2651    var wasAlphaNumericChar = /[a-zA-Z0-9-_ ]/.test(keyString);
2652    var BACK_KEY = constants_1.KEY_CODES.BACK_KEY,
2653        DELETE_KEY = constants_1.KEY_CODES.DELETE_KEY,
2654        ENTER_KEY = constants_1.KEY_CODES.ENTER_KEY,
2655        A_KEY = constants_1.KEY_CODES.A_KEY,
2656        ESC_KEY = constants_1.KEY_CODES.ESC_KEY,
2657        UP_KEY = constants_1.KEY_CODES.UP_KEY,
2658        DOWN_KEY = constants_1.KEY_CODES.DOWN_KEY,
2659        PAGE_UP_KEY = constants_1.KEY_CODES.PAGE_UP_KEY,
2660        PAGE_DOWN_KEY = constants_1.KEY_CODES.PAGE_DOWN_KEY;
2661
2662    if (!this._isTextElement && !hasActiveDropdown && wasAlphaNumericChar) {
2663      this.showDropdown();
2664
2665      if (!this.input.isFocussed) {
2666        /*
2667          We update the input value with the pressed key as
2668          the input was not focussed at the time of key press
2669          therefore does not have the value of the key.
2670        */
2671        this.input.value += keyString.toLowerCase();
2672      }
2673    }
2674
2675    switch (keyCode) {
2676      case A_KEY:
2677        return this._onSelectKey(event, hasItems);
2678
2679      case ENTER_KEY:
2680        return this._onEnterKey(event, activeItems, hasActiveDropdown);
2681
2682      case ESC_KEY:
2683        return this._onEscapeKey(hasActiveDropdown);
2684
2685      case UP_KEY:
2686      case PAGE_UP_KEY:
2687      case DOWN_KEY:
2688      case PAGE_DOWN_KEY:
2689        return this._onDirectionKey(event, hasActiveDropdown);
2690
2691      case DELETE_KEY:
2692      case BACK_KEY:
2693        return this._onDeleteKey(event, activeItems, hasFocusedInput);
2694
2695      default:
2696    }
2697  };
2698
2699  Choices.prototype._onKeyUp = function (_a) {
2700    var target = _a.target,
2701        keyCode = _a.keyCode;
2702    var value = this.input.value;
2703    var activeItems = this._store.activeItems;
2704
2705    var canAddItem = this._canAddItem(activeItems, value);
2706
2707    var backKey = constants_1.KEY_CODES.BACK_KEY,
2708        deleteKey = constants_1.KEY_CODES.DELETE_KEY; // We are typing into a text input and have a value, we want to show a dropdown
2709    // notice. Otherwise hide the dropdown
2710
2711    if (this._isTextElement) {
2712      var canShowDropdownNotice = canAddItem.notice && value;
2713
2714      if (canShowDropdownNotice) {
2715        var dropdownItem = this._getTemplate('notice', canAddItem.notice);
2716
2717        this.dropdown.element.innerHTML = dropdownItem.outerHTML;
2718        this.showDropdown(true);
2719      } else {
2720        this.hideDropdown(true);
2721      }
2722    } else {
2723      var wasRemovalKeyCode = keyCode === backKey || keyCode === deleteKey;
2724      var userHasRemovedValue = wasRemovalKeyCode && target && !target.value;
2725      var canReactivateChoices = !this._isTextElement && this._isSearching;
2726      var canSearch = this._canSearch && canAddItem.response;
2727
2728      if (userHasRemovedValue && canReactivateChoices) {
2729        this._isSearching = false;
2730
2731        this._store.dispatch(choices_1.activateChoices(true));
2732      } else if (canSearch) {
2733        this._handleSearch(this.input.value);
2734      }
2735    }
2736
2737    this._canSearch = this.config.searchEnabled;
2738  };
2739
2740  Choices.prototype._onSelectKey = function (event, hasItems) {
2741    var ctrlKey = event.ctrlKey,
2742        metaKey = event.metaKey;
2743    var hasCtrlDownKeyPressed = ctrlKey || metaKey; // If CTRL + A or CMD + A have been pressed and there are items to select
2744
2745    if (hasCtrlDownKeyPressed && hasItems) {
2746      this._canSearch = false;
2747      var shouldHightlightAll = this.config.removeItems && !this.input.value && this.input.element === document.activeElement;
2748
2749      if (shouldHightlightAll) {
2750        this.highlightAll();
2751      }
2752    }
2753  };
2754
2755  Choices.prototype._onEnterKey = function (event, activeItems, hasActiveDropdown) {
2756    var target = event.target;
2757    var enterKey = constants_1.KEY_CODES.ENTER_KEY;
2758    var targetWasButton = target && target.hasAttribute('data-button');
2759
2760    if (this._isTextElement && target && target.value) {
2761      var value = this.input.value;
2762
2763      var canAddItem = this._canAddItem(activeItems, value);
2764
2765      if (canAddItem.response) {
2766        this.hideDropdown(true);
2767
2768        this._addItem({
2769          value: value
2770        });
2771
2772        this._triggerChange(value);
2773
2774        this.clearInput();
2775      }
2776    }
2777
2778    if (targetWasButton) {
2779      this._handleButtonAction(activeItems, target);
2780
2781      event.preventDefault();
2782    }
2783
2784    if (hasActiveDropdown) {
2785      var highlightedChoice = this.dropdown.getChild("." + this.config.classNames.highlightedState);
2786
2787      if (highlightedChoice) {
2788        // add enter keyCode value
2789        if (activeItems[0]) {
2790          activeItems[0].keyCode = enterKey; // eslint-disable-line no-param-reassign
2791        }
2792
2793        this._handleChoiceAction(activeItems, highlightedChoice);
2794      }
2795
2796      event.preventDefault();
2797    } else if (this._isSelectOneElement) {
2798      this.showDropdown();
2799      event.preventDefault();
2800    }
2801  };
2802
2803  Choices.prototype._onEscapeKey = function (hasActiveDropdown) {
2804    if (hasActiveDropdown) {
2805      this.hideDropdown(true);
2806      this.containerOuter.focus();
2807    }
2808  };
2809
2810  Choices.prototype._onDirectionKey = function (event, hasActiveDropdown) {
2811    var keyCode = event.keyCode,
2812        metaKey = event.metaKey;
2813    var downKey = constants_1.KEY_CODES.DOWN_KEY,
2814        pageUpKey = constants_1.KEY_CODES.PAGE_UP_KEY,
2815        pageDownKey = constants_1.KEY_CODES.PAGE_DOWN_KEY; // If up or down key is pressed, traverse through options
2816
2817    if (hasActiveDropdown || this._isSelectOneElement) {
2818      this.showDropdown();
2819      this._canSearch = false;
2820      var directionInt = keyCode === downKey || keyCode === pageDownKey ? 1 : -1;
2821      var skipKey = metaKey || keyCode === pageDownKey || keyCode === pageUpKey;
2822      var selectableChoiceIdentifier = '[data-choice-selectable]';
2823      var nextEl = void 0;
2824
2825      if (skipKey) {
2826        if (directionInt > 0) {
2827          nextEl = this.dropdown.element.querySelector(selectableChoiceIdentifier + ":last-of-type");
2828        } else {
2829          nextEl = this.dropdown.element.querySelector(selectableChoiceIdentifier);
2830        }
2831      } else {
2832        var currentEl = this.dropdown.element.querySelector("." + this.config.classNames.highlightedState);
2833
2834        if (currentEl) {
2835          nextEl = utils_1.getAdjacentEl(currentEl, selectableChoiceIdentifier, directionInt);
2836        } else {
2837          nextEl = this.dropdown.element.querySelector(selectableChoiceIdentifier);
2838        }
2839      }
2840
2841      if (nextEl) {
2842        // We prevent default to stop the cursor moving
2843        // when pressing the arrow
2844        if (!utils_1.isScrolledIntoView(nextEl, this.choiceList.element, directionInt)) {
2845          this.choiceList.scrollToChildElement(nextEl, directionInt);
2846        }
2847
2848        this._highlightChoice(nextEl);
2849      } // Prevent default to maintain cursor position whilst
2850      // traversing dropdown options
2851
2852
2853      event.preventDefault();
2854    }
2855  };
2856
2857  Choices.prototype._onDeleteKey = function (event, activeItems, hasFocusedInput) {
2858    var target = event.target; // If backspace or delete key is pressed and the input has no value
2859
2860    if (!this._isSelectOneElement && !target.value && hasFocusedInput) {
2861      this._handleBackspace(activeItems);
2862
2863      event.preventDefault();
2864    }
2865  };
2866
2867  Choices.prototype._onTouchMove = function () {
2868    if (this._wasTap) {
2869      this._wasTap = false;
2870    }
2871  };
2872
2873  Choices.prototype._onTouchEnd = function (event) {
2874    var target = (event || event.touches[0]).target;
2875    var touchWasWithinContainer = this._wasTap && this.containerOuter.element.contains(target);
2876
2877    if (touchWasWithinContainer) {
2878      var containerWasExactTarget = target === this.containerOuter.element || target === this.containerInner.element;
2879
2880      if (containerWasExactTarget) {
2881        if (this._isTextElement) {
2882          this.input.focus();
2883        } else if (this._isSelectMultipleElement) {
2884          this.showDropdown();
2885        }
2886      } // Prevents focus event firing
2887
2888
2889      event.stopPropagation();
2890    }
2891
2892    this._wasTap = true;
2893  };
2894  /**
2895   * Handles mousedown event in capture mode for containetOuter.element
2896   */
2897
2898
2899  Choices.prototype._onMouseDown = function (event) {
2900    var target = event.target;
2901
2902    if (!(target instanceof HTMLElement)) {
2903      return;
2904    } // If we have our mouse down on the scrollbar and are on IE11...
2905
2906
2907    if (IS_IE11 && this.choiceList.element.contains(target)) {
2908      // check if click was on a scrollbar area
2909      var firstChoice = this.choiceList.element.firstElementChild;
2910      var isOnScrollbar = this._direction === 'ltr' ? event.offsetX >= firstChoice.offsetWidth : event.offsetX < firstChoice.offsetLeft;
2911      this._isScrollingOnIe = isOnScrollbar;
2912    }
2913
2914    if (target === this.input.element) {
2915      return;
2916    }
2917
2918    var item = target.closest('[data-button],[data-item],[data-choice]');
2919
2920    if (item instanceof HTMLElement) {
2921      var hasShiftKey = event.shiftKey;
2922      var activeItems = this._store.activeItems;
2923      var dataset = item.dataset;
2924
2925      if ('button' in dataset) {
2926        this._handleButtonAction(activeItems, item);
2927      } else if ('item' in dataset) {
2928        this._handleItemAction(activeItems, item, hasShiftKey);
2929      } else if ('choice' in dataset) {
2930        this._handleChoiceAction(activeItems, item);
2931      }
2932    }
2933
2934    event.preventDefault();
2935  };
2936  /**
2937   * Handles mouseover event over this.dropdown
2938   * @param {MouseEvent} event
2939   */
2940
2941
2942  Choices.prototype._onMouseOver = function (_a) {
2943    var target = _a.target;
2944
2945    if (target instanceof HTMLElement && 'choice' in target.dataset) {
2946      this._highlightChoice(target);
2947    }
2948  };
2949
2950  Choices.prototype._onClick = function (_a) {
2951    var target = _a.target;
2952    var clickWasWithinContainer = this.containerOuter.element.contains(target);
2953
2954    if (clickWasWithinContainer) {
2955      if (!this.dropdown.isActive && !this.containerOuter.isDisabled) {
2956        if (this._isTextElement) {
2957          if (document.activeElement !== this.input.element) {
2958            this.input.focus();
2959          }
2960        } else {
2961          this.showDropdown();
2962          this.containerOuter.focus();
2963        }
2964      } else if (this._isSelectOneElement && target !== this.input.element && !this.dropdown.element.contains(target)) {
2965        this.hideDropdown();
2966      }
2967    } else {
2968      var hasHighlightedItems = this._store.highlightedActiveItems.length > 0;
2969
2970      if (hasHighlightedItems) {
2971        this.unhighlightAll();
2972      }
2973
2974      this.containerOuter.removeFocusState();
2975      this.hideDropdown(true);
2976    }
2977  };
2978
2979  Choices.prototype._onFocus = function (_a) {
2980    var _b;
2981
2982    var _this = this;
2983
2984    var target = _a.target;
2985    var focusWasWithinContainer = target && this.containerOuter.element.contains(target);
2986
2987    if (!focusWasWithinContainer) {
2988      return;
2989    }
2990
2991    var focusActions = (_b = {}, _b[constants_1.TEXT_TYPE] = function () {
2992      if (target === _this.input.element) {
2993        _this.containerOuter.addFocusState();
2994      }
2995    }, _b[constants_1.SELECT_ONE_TYPE] = function () {
2996      _this.containerOuter.addFocusState();
2997
2998      if (target === _this.input.element) {
2999        _this.showDropdown(true);
3000      }
3001    }, _b[constants_1.SELECT_MULTIPLE_TYPE] = function () {
3002      if (target === _this.input.element) {
3003        _this.showDropdown(true); // If element is a select box, the focused element is the container and the dropdown
3004        // isn't already open, focus and show dropdown
3005
3006
3007        _this.containerOuter.addFocusState();
3008      }
3009    }, _b);
3010    focusActions[this.passedElement.element.type]();
3011  };
3012
3013  Choices.prototype._onBlur = function (_a) {
3014    var _b;
3015
3016    var _this = this;
3017
3018    var target = _a.target;
3019    var blurWasWithinContainer = target && this.containerOuter.element.contains(target);
3020
3021    if (blurWasWithinContainer && !this._isScrollingOnIe) {
3022      var activeItems = this._store.activeItems;
3023      var hasHighlightedItems_1 = activeItems.some(function (item) {
3024        return item.highlighted;
3025      });
3026      var blurActions = (_b = {}, _b[constants_1.TEXT_TYPE] = function () {
3027        if (target === _this.input.element) {
3028          _this.containerOuter.removeFocusState();
3029
3030          if (hasHighlightedItems_1) {
3031            _this.unhighlightAll();
3032          }
3033
3034          _this.hideDropdown(true);
3035        }
3036      }, _b[constants_1.SELECT_ONE_TYPE] = function () {
3037        _this.containerOuter.removeFocusState();
3038
3039        if (target === _this.input.element || target === _this.containerOuter.element && !_this._canSearch) {
3040          _this.hideDropdown(true);
3041        }
3042      }, _b[constants_1.SELECT_MULTIPLE_TYPE] = function () {
3043        if (target === _this.input.element) {
3044          _this.containerOuter.removeFocusState();
3045
3046          _this.hideDropdown(true);
3047
3048          if (hasHighlightedItems_1) {
3049            _this.unhighlightAll();
3050          }
3051        }
3052      }, _b);
3053      blurActions[this.passedElement.element.type]();
3054    } else {
3055      // On IE11, clicking the scollbar blurs our input and thus
3056      // closes the dropdown. To stop this, we refocus our input
3057      // if we know we are on IE *and* are scrolling.
3058      this._isScrollingOnIe = false;
3059      this.input.element.focus();
3060    }
3061  };
3062
3063  Choices.prototype._onFormReset = function () {
3064    this._store.dispatch(misc_1.resetTo(this._initialState));
3065  };
3066
3067  Choices.prototype._highlightChoice = function (el) {
3068    var _this = this;
3069
3070    if (el === void 0) {
3071      el = null;
3072    }
3073
3074    var choices = Array.from(this.dropdown.element.querySelectorAll('[data-choice-selectable]'));
3075
3076    if (!choices.length) {
3077      return;
3078    }
3079
3080    var passedEl = el;
3081    var highlightedChoices = Array.from(this.dropdown.element.querySelectorAll("." + this.config.classNames.highlightedState)); // Remove any highlighted choices
3082
3083    highlightedChoices.forEach(function (choice) {
3084      choice.classList.remove(_this.config.classNames.highlightedState);
3085      choice.setAttribute('aria-selected', 'false');
3086    });
3087
3088    if (passedEl) {
3089      this._highlightPosition = choices.indexOf(passedEl);
3090    } else {
3091      // Highlight choice based on last known highlight location
3092      if (choices.length > this._highlightPosition) {
3093        // If we have an option to highlight
3094        passedEl = choices[this._highlightPosition];
3095      } else {
3096        // Otherwise highlight the option before
3097        passedEl = choices[choices.length - 1];
3098      }
3099
3100      if (!passedEl) {
3101        passedEl = choices[0];
3102      }
3103    }
3104
3105    passedEl.classList.add(this.config.classNames.highlightedState);
3106    passedEl.setAttribute('aria-selected', 'true');
3107    this.passedElement.triggerEvent(constants_1.EVENTS.highlightChoice, {
3108      el: passedEl
3109    });
3110
3111    if (this.dropdown.isActive) {
3112      // IE11 ignores aria-label and blocks virtual keyboard
3113      // if aria-activedescendant is set without a dropdown
3114      this.input.setActiveDescendant(passedEl.id);
3115      this.containerOuter.setActiveDescendant(passedEl.id);
3116    }
3117  };
3118
3119  Choices.prototype._addItem = function (_a) {
3120    var value = _a.value,
3121        _b = _a.label,
3122        label = _b === void 0 ? null : _b,
3123        _c = _a.choiceId,
3124        choiceId = _c === void 0 ? -1 : _c,
3125        _d = _a.groupId,
3126        groupId = _d === void 0 ? -1 : _d,
3127        _e = _a.customProperties,
3128        customProperties = _e === void 0 ? {} : _e,
3129        _f = _a.placeholder,
3130        placeholder = _f === void 0 ? false : _f,
3131        _g = _a.keyCode,
3132        keyCode = _g === void 0 ? -1 : _g;
3133    var passedValue = typeof value === 'string' ? value.trim() : value;
3134    var items = this._store.items;
3135    var passedLabel = label || passedValue;
3136    var passedOptionId = choiceId || -1;
3137    var group = groupId >= 0 ? this._store.getGroupById(groupId) : null;
3138    var id = items ? items.length + 1 : 1; // If a prepended value has been passed, prepend it
3139
3140    if (this.config.prependValue) {
3141      passedValue = this.config.prependValue + passedValue.toString();
3142    } // If an appended value has been passed, append it
3143
3144
3145    if (this.config.appendValue) {
3146      passedValue += this.config.appendValue.toString();
3147    }
3148
3149    this._store.dispatch(items_1.addItem({
3150      value: passedValue,
3151      label: passedLabel,
3152      id: id,
3153      choiceId: passedOptionId,
3154      groupId: groupId,
3155      customProperties: customProperties,
3156      placeholder: placeholder,
3157      keyCode: keyCode
3158    }));
3159
3160    if (this._isSelectOneElement) {
3161      this.removeActiveItems(id);
3162    } // Trigger change event
3163
3164
3165    this.passedElement.triggerEvent(constants_1.EVENTS.addItem, {
3166      id: id,
3167      value: passedValue,
3168      label: passedLabel,
3169      customProperties: customProperties,
3170      groupValue: group && group.value ? group.value : null,
3171      keyCode: keyCode
3172    });
3173  };
3174
3175  Choices.prototype._removeItem = function (item) {
3176    var id = item.id,
3177        value = item.value,
3178        label = item.label,
3179        customProperties = item.customProperties,
3180        choiceId = item.choiceId,
3181        groupId = item.groupId;
3182    var group = groupId && groupId >= 0 ? this._store.getGroupById(groupId) : null;
3183
3184    if (!id || !choiceId) {
3185      return;
3186    }
3187
3188    this._store.dispatch(items_1.removeItem(id, choiceId));
3189
3190    this.passedElement.triggerEvent(constants_1.EVENTS.removeItem, {
3191      id: id,
3192      value: value,
3193      label: label,
3194      customProperties: customProperties,
3195      groupValue: group && group.value ? group.value : null
3196    });
3197  };
3198
3199  Choices.prototype._addChoice = function (_a) {
3200    var value = _a.value,
3201        _b = _a.label,
3202        label = _b === void 0 ? null : _b,
3203        _c = _a.isSelected,
3204        isSelected = _c === void 0 ? false : _c,
3205        _d = _a.isDisabled,
3206        isDisabled = _d === void 0 ? false : _d,
3207        _e = _a.groupId,
3208        groupId = _e === void 0 ? -1 : _e,
3209        _f = _a.customProperties,
3210        customProperties = _f === void 0 ? {}