diff --git a/.eslintrc b/.eslintrc
index 51bfd7c..b77bb35 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -20,13 +20,16 @@
"expect": true,
"browser": true,
"by": true,
- "element": true
+ "element": true,
+ "cy": true
},
"parser": "babel-eslint",
"rules": {
"strict": 0,
"no-underscore-dangle": 0,
- "no-console": ["warn", { allow: ["warn", "error"] }],
+ "no-console": ["warn", {
+ "allow": ["warn", "error"]
+ }],
"space-before-function-paren": 0
}
}
diff --git a/cypress/integration/example_spec.js b/cypress/integration/example_spec.js
index 562d88d..7b73eae 100644
--- a/cypress/integration/example_spec.js
+++ b/cypress/integration/example_spec.js
@@ -11,1487 +11,71 @@
// Please read our "Introduction to Cypress"
// https://on.cypress.io/introduction-to-cypress
-describe('Kitchen Sink', function () {
- it('.should() - assert that
is correct', function () {
- // https://on.cypress.io/visit
- cy.visit('https://example.cypress.io')
+describe('Choices', () => {
+ context('Misc', () => {
+ beforeEach(() => {
+ cy.visit('http://localhost:3000');
+ });
- // Here we've made our first assertion using a '.should()' command.
- // An assertion is comprised of a chainer, subject, and optional value.
-
- // https://on.cypress.io/should
- // https://on.cypress.io/and
-
- // https://on.cypress.io/title
- cy.title().should('include', 'Kitchen Sink')
- // ↲ ↲ ↲
- // subject chainer value
- })
-
- context('Querying', function () {
- beforeEach(function () {
- // Visiting our app before each test removes any state build up from
- // previous tests. Visiting acts as if we closed a tab and opened a fresh one
- cy.visit('https://example.cypress.io/commands/querying')
- })
-
- // Let's query for some DOM elements and make assertions
- // The most commonly used query is 'cy.get()', you can
- // think of this like the '$' in jQuery
-
- it('cy.get() - query DOM elements', function () {
- // https://on.cypress.io/get
-
- // Get DOM elements by id
- cy.get('#query-btn').should('contain', 'Button')
-
- // Get DOM elements by class
- cy.get('.query-btn').should('contain', 'Button')
-
- cy.get('#querying .well>button:first').should('contain', 'Button')
- // ↲
- // Use CSS selectors just like jQuery
- })
-
- it('cy.contains() - query DOM elements with matching content', function () {
- // https://on.cypress.io/contains
- cy.get('.query-list')
- .contains('bananas').should('have.class', 'third')
-
- // we can pass a regexp to `.contains()`
- cy.get('.query-list')
- .contains(/^b\w+/).should('have.class', 'third')
-
- cy.get('.query-list')
- .contains('apples').should('have.class', 'first')
-
- // passing a selector to contains will yield the selector containing the text
- cy.get('#querying')
- .contains('ul', 'oranges').should('have.class', 'query-list')
-
- // `.contains()` will favor input[type='submit'],
- // button, a, and label over deeper elements inside them
- // this will not yield the inside the button,
- // but the ');
+ testEl.style.position = 'absolute';
+ testEl.style.padding = '0';
+ testEl.style.top = '-9999px';
+ testEl.style.left = '-9999px';
+ testEl.style.width = 'auto';
+ testEl.style.whiteSpace = 'pre';
+
+ if (document.body.contains(input) && window.getComputedStyle) {
+ var inputStyle = window.getComputedStyle(input);
+
+ if (inputStyle) {
+ testEl.style.fontSize = inputStyle.fontSize;
+ testEl.style.fontFamily = inputStyle.fontFamily;
+ testEl.style.fontWeight = inputStyle.fontWeight;
+ testEl.style.fontStyle = inputStyle.fontStyle;
+ testEl.style.letterSpacing = inputStyle.letterSpacing;
+ testEl.style.textTransform = inputStyle.textTransform;
+ testEl.style.padding = inputStyle.padding;
+ }
+ }
+
+ document.body.appendChild(testEl);
+
+ if (value && testEl.offsetWidth !== input.offsetWidth) {
+ width = testEl.offsetWidth + 4;
+ }
+
+ document.body.removeChild(testEl);
+ }
+
+ return width + 'px';
+};
+
+/**
+ * Sorting function for current and previous string
+ * @param {String} a Current value
+ * @param {String} b Next value
+ * @return {Number} -1 for after previous,
+ * 1 for before,
+ * 0 for same location
+ */
+var sortByAlpha = exports.sortByAlpha = function sortByAlpha(a, b) {
+ var labelA = (a.label || a.value).toLowerCase();
+ var labelB = (b.label || b.value).toLowerCase();
+
+ if (labelA < labelB) return -1;
+ if (labelA > labelB) return 1;
+ return 0;
+};
+
+/**
+ * Sort by numeric score
+ * @param {Object} a Current value
+ * @param {Object} b Next value
+ * @return {Number} -1 for after previous,
+ * 1 for before,
+ * 0 for same location
+ */
+var sortByScore = exports.sortByScore = function sortByScore(a, b) {
+ return a.score - b.score;
+};
+
+/**
+ * Dispatch native event
+ * @param {NodeElement} element Element to trigger event on
+ * @param {String} type Type of event to trigger
+ * @param {Object} customArgs Data to pass with event
+ * @return {Object} Triggered event
+ */
+var dispatchEvent = exports.dispatchEvent = function dispatchEvent(element, type) {
+ var customArgs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+ var event = new CustomEvent(type, {
+ detail: customArgs,
+ bubbles: true,
+ cancelable: true
+ });
+
+ return element.dispatchEvent(event);
+};
+
+/**
+ * Tests value against a regular expression
+ * @param {string} value Value to test
+ * @return {Boolean} Whether test passed/failed
+ * @private
+ */
+var regexFilter = exports.regexFilter = function regexFilter(value, regex) {
+ if (!value || !regex) {
+ return false;
+ }
+
+ var expression = new RegExp(regex.source, 'i');
+ return expression.test(value);
+};
+
+var getWindowHeight = exports.getWindowHeight = function getWindowHeight() {
+ var body = document.body;
+ var html = document.documentElement;
+ return Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight);
+};
+
+var reduceToValues = exports.reduceToValues = function reduceToValues(items) {
+ var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'value';
+
+ var values = items.reduce(function (prev, current) {
+ prev.push(current[key]);
+ return prev;
+ }, []);
+
+ return values;
+};
+
+var isIE11 = exports.isIE11 = function isIE11() {
+ return !!(navigator.userAgent.match(/Trident/) && navigator.userAgent.match(/rv[ :]11/));
+};
+
+/***/ }),
+/* 2 */
+/***/ (function(module, exports) {
+
+// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+var global = module.exports = typeof window != 'undefined' && window.Math == Math
+ ? window : typeof self != 'undefined' && self.Math == Math ? self
+ // eslint-disable-next-line no-new-func
+ : Function('return this')();
+if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef
+
+
+/***/ }),
+/* 3 */
+/***/ (function(module, exports) {
+
+var core = module.exports = { version: '2.5.6' };
+if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
+
+
+/***/ }),
+/* 4 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var dP = __webpack_require__(5);
+var createDesc = __webpack_require__(13);
+module.exports = __webpack_require__(7) ? function (object, key, value) {
+ return dP.f(object, key, createDesc(1, value));
+} : function (object, key, value) {
+ object[key] = value;
+ return object;
+};
+
+
+/***/ }),
+/* 5 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var anObject = __webpack_require__(6);
+var IE8_DOM_DEFINE = __webpack_require__(42);
+var toPrimitive = __webpack_require__(43);
+var dP = Object.defineProperty;
+
+exports.f = __webpack_require__(7) ? Object.defineProperty : function defineProperty(O, P, Attributes) {
+ anObject(O);
+ P = toPrimitive(P, true);
+ anObject(Attributes);
+ if (IE8_DOM_DEFINE) try {
+ return dP(O, P, Attributes);
+ } catch (e) { /* empty */ }
+ if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
+ if ('value' in Attributes) O[P] = Attributes.value;
+ return O;
+};
+
+
+/***/ }),
+/* 6 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var isObject = __webpack_require__(12);
+module.exports = function (it) {
+ if (!isObject(it)) throw TypeError(it + ' is not an object!');
+ return it;
+};
+
+
+/***/ }),
+/* 7 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// Thank's IE8 for his funny defineProperty
+module.exports = !__webpack_require__(19)(function () {
+ return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
+});
+
+
+/***/ }),
+/* 8 */
+/***/ (function(module, exports) {
+
+var hasOwnProperty = {}.hasOwnProperty;
+module.exports = function (it, key) {
+ return hasOwnProperty.call(it, key);
+};
+
+
+/***/ }),
+/* 9 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.SCROLLING_SPEED = exports.KEY_CODES = exports.ACTION_TYPES = exports.EVENTS = exports.DEFAULT_CONFIG = exports.DEFAULT_CLASSNAMES = undefined;
+
+var _utils = __webpack_require__(1);
+
+var DEFAULT_CLASSNAMES = exports.DEFAULT_CLASSNAMES = {
+ containerOuter: 'choices',
+ containerInner: 'choices__inner',
+ input: 'choices__input',
+ inputCloned: 'choices__input--cloned',
+ list: 'choices__list',
+ listItems: 'choices__list--multiple',
+ listSingle: 'choices__list--single',
+ listDropdown: 'choices__list--dropdown',
+ item: 'choices__item',
+ itemSelectable: 'choices__item--selectable',
+ itemDisabled: 'choices__item--disabled',
+ itemChoice: 'choices__item--choice',
+ placeholder: 'choices__placeholder',
+ group: 'choices__group',
+ groupHeading: 'choices__heading',
+ button: 'choices__button',
+ activeState: 'is-active',
+ focusState: 'is-focused',
+ openState: 'is-open',
+ disabledState: 'is-disabled',
+ highlightedState: 'is-highlighted',
+ hiddenState: 'is-hidden',
+ flippedState: 'is-flipped',
+ loadingState: 'is-loading',
+ noResults: 'has-no-results',
+ noChoices: 'has-no-choices'
+};
+
+var DEFAULT_CONFIG = exports.DEFAULT_CONFIG = {
+ items: [],
+ choices: [],
+ silent: false,
+ renderChoiceLimit: -1,
+ maxItemCount: -1,
+ addItems: true,
+ removeItems: true,
+ removeItemButton: false,
+ editItems: false,
+ duplicateItems: true,
+ delimiter: ',',
+ paste: true,
+ searchEnabled: true,
+ searchChoices: true,
+ searchFloor: 1,
+ searchResultLimit: 4,
+ searchFields: ['label', 'value'],
+ position: 'auto',
+ resetScrollPosition: true,
+ regexFilter: null,
+ shouldSort: true,
+ shouldSortItems: false,
+ placeholder: true,
+ placeholderValue: null,
+ searchPlaceholderValue: null,
+ prependValue: null,
+ appendValue: null,
+ renderSelectedChoices: 'auto',
+ loadingText: 'Loading...',
+ noResultsText: 'No results found',
+ noChoicesText: 'No choices to choose from',
+ itemSelectText: 'Press to select',
+ uniqueItemText: 'Only unique values can be added.',
+ addItemText: function addItemText(value) {
+ return 'Press Enter to add "' + (0, _utils.stripHTML)(value) + '"';
+ },
+ maxItemText: function maxItemText(maxItemCount) {
+ return 'Only ' + maxItemCount + ' values can be added.';
+ },
+ itemComparer: function itemComparer(choice, item) {
+ return choice === item;
+ },
+ fuseOptions: {
+ includeScore: true
+ },
+ callbackOnInit: null,
+ callbackOnCreateTemplates: null
+};
+
+var EVENTS = exports.EVENTS = {
+ showDropdown: 'showDropdown',
+ hideDropdown: 'hideDropdown',
+ change: 'change',
+ choice: 'choice',
+ search: 'search',
+ addItem: 'addItem',
+ removeItem: 'removeItem',
+ highlightItem: 'highlightItem'
+};
+
+var ACTION_TYPES = exports.ACTION_TYPES = {
+ ADD_CHOICE: 'ADD_CHOICE',
+ FILTER_CHOICES: 'FILTER_CHOICES',
+ ACTIVATE_CHOICES: 'ACTIVATE_CHOICES',
+ CLEAR_CHOICES: 'CLEAR_CHOICES',
+ ADD_GROUP: 'ADD_GROUP',
+ ADD_ITEM: 'ADD_ITEM',
+ REMOVE_ITEM: 'REMOVE_ITEM',
+ HIGHLIGHT_ITEM: 'HIGHLIGHT_ITEM',
+ CLEAR_ALL: 'CLEAR_ALL'
+};
+
+var KEY_CODES = exports.KEY_CODES = {
+ BACK_KEY: 46,
+ DELETE_KEY: 8,
+ ENTER_KEY: 13,
+ A_KEY: 65,
+ ESC_KEY: 27,
+ UP_KEY: 38,
+ DOWN_KEY: 40,
+ PAGE_UP_KEY: 33,
+ PAGE_DOWN_KEY: 34
+};
+
+var SCROLLING_SPEED = exports.SCROLLING_SPEED = 4;
+
+/***/ }),
+/* 10 */
+/***/ (function(module, exports) {
+
+// 7.1.4 ToInteger
+var ceil = Math.ceil;
+var floor = Math.floor;
+module.exports = function (it) {
+ return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
+};
+
+
+/***/ }),
+/* 11 */
+/***/ (function(module, exports) {
+
+// 7.2.1 RequireObjectCoercible(argument)
+module.exports = function (it) {
+ if (it == undefined) throw TypeError("Can't call method on " + it);
+ return it;
+};
+
+
+/***/ }),
+/* 12 */
+/***/ (function(module, exports) {
+
+module.exports = function (it) {
+ return typeof it === 'object' ? it !== null : typeof it === 'function';
+};
+
+
+/***/ }),
+/* 13 */
+/***/ (function(module, exports) {
+
+module.exports = function (bitmap, value) {
+ return {
+ enumerable: !(bitmap & 1),
+ configurable: !(bitmap & 2),
+ writable: !(bitmap & 4),
+ value: value
+ };
+};
+
+
+/***/ }),
+/* 14 */
+/***/ (function(module, exports) {
+
+var id = 0;
+var px = Math.random();
+module.exports = function (key) {
+ return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
+};
+
+
+/***/ }),
+/* 15 */
+/***/ (function(module, exports) {
+
+module.exports = {};
+
+
+/***/ }),
+/* 16 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var shared = __webpack_require__(26)('keys');
+var uid = __webpack_require__(14);
+module.exports = function (key) {
+ return shared[key] || (shared[key] = uid(key));
+};
+
+
+/***/ }),
+/* 17 */
+/***/ (function(module, exports) {
+
+module.exports = false;
+
+
+/***/ }),
+/* 18 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var global = __webpack_require__(2);
+var core = __webpack_require__(3);
+var hide = __webpack_require__(4);
+var redefine = __webpack_require__(21);
+var ctx = __webpack_require__(22);
+var PROTOTYPE = 'prototype';
+
+var $export = function (type, name, source) {
+ var IS_FORCED = type & $export.F;
+ var IS_GLOBAL = type & $export.G;
+ var IS_STATIC = type & $export.S;
+ var IS_PROTO = type & $export.P;
+ var IS_BIND = type & $export.B;
+ var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE];
+ var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
+ var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});
+ var key, own, out, exp;
+ if (IS_GLOBAL) source = name;
+ for (key in source) {
+ // contains in native
+ own = !IS_FORCED && target && target[key] !== undefined;
+ // export native or passed
+ out = (own ? target : source)[key];
+ // bind timers to global for call from export context
+ exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
+ // extend global
+ if (target) redefine(target, key, out, type & $export.U);
+ // export
+ if (exports[key] != out) hide(exports, key, exp);
+ if (IS_PROTO && expProto[key] != out) expProto[key] = out;
+ }
+};
+global.core = core;
+// type bitmap
+$export.F = 1; // forced
+$export.G = 2; // global
+$export.S = 4; // static
+$export.P = 8; // proto
+$export.B = 16; // bind
+$export.W = 32; // wrap
+$export.U = 64; // safe
+$export.R = 128; // real proto method for `library`
+module.exports = $export;
+
+
+/***/ }),
+/* 19 */
+/***/ (function(module, exports) {
+
+module.exports = function (exec) {
+ try {
+ return !!exec();
+ } catch (e) {
+ return true;
+ }
+};
+
+
+/***/ }),
+/* 20 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var isObject = __webpack_require__(12);
+var document = __webpack_require__(2).document;
+// typeof document.createElement is 'object' in old IE
+var is = isObject(document) && isObject(document.createElement);
+module.exports = function (it) {
+ return is ? document.createElement(it) : {};
+};
+
+
+/***/ }),
+/* 21 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var global = __webpack_require__(2);
+var hide = __webpack_require__(4);
+var has = __webpack_require__(8);
+var SRC = __webpack_require__(14)('src');
+var TO_STRING = 'toString';
+var $toString = Function[TO_STRING];
+var TPL = ('' + $toString).split(TO_STRING);
+
+__webpack_require__(3).inspectSource = function (it) {
+ return $toString.call(it);
+};
+
+(module.exports = function (O, key, val, safe) {
+ var isFunction = typeof val == 'function';
+ if (isFunction) has(val, 'name') || hide(val, 'name', key);
+ if (O[key] === val) return;
+ if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
+ if (O === global) {
+ O[key] = val;
+ } else if (!safe) {
+ delete O[key];
+ hide(O, key, val);
+ } else if (O[key]) {
+ O[key] = val;
+ } else {
+ hide(O, key, val);
+ }
+// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+})(Function.prototype, TO_STRING, function toString() {
+ return typeof this == 'function' && this[SRC] || $toString.call(this);
+});
+
+
+/***/ }),
+/* 22 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// optional / simple context binding
+var aFunction = __webpack_require__(44);
+module.exports = function (fn, that, length) {
+ aFunction(fn);
+ if (that === undefined) return fn;
+ switch (length) {
+ case 1: return function (a) {
+ return fn.call(that, a);
+ };
+ case 2: return function (a, b) {
+ return fn.call(that, a, b);
+ };
+ case 3: return function (a, b, c) {
+ return fn.call(that, a, b, c);
+ };
+ }
+ return function (/* ...args */) {
+ return fn.apply(that, arguments);
+ };
+};
+
+
+/***/ }),
+/* 23 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// to indexed object, toObject with fallback for non-array-like ES3 strings
+var IObject = __webpack_require__(50);
+var defined = __webpack_require__(11);
+module.exports = function (it) {
+ return IObject(defined(it));
+};
+
+
+/***/ }),
+/* 24 */
+/***/ (function(module, exports) {
+
+var toString = {}.toString;
+
+module.exports = function (it) {
+ return toString.call(it).slice(8, -1);
+};
+
+
+/***/ }),
+/* 25 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 7.1.15 ToLength
+var toInteger = __webpack_require__(10);
+var min = Math.min;
+module.exports = function (it) {
+ return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
+};
+
+
+/***/ }),
+/* 26 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var core = __webpack_require__(3);
+var global = __webpack_require__(2);
+var SHARED = '__core-js_shared__';
+var store = global[SHARED] || (global[SHARED] = {});
+
+(module.exports = function (key, value) {
+ return store[key] || (store[key] = value !== undefined ? value : {});
+})('versions', []).push({
+ version: core.version,
+ mode: __webpack_require__(17) ? 'pure' : 'global',
+ copyright: '© 2018 Denis Pushkarev (zloirock.ru)'
+});
+
+
+/***/ }),
+/* 27 */
+/***/ (function(module, exports) {
+
+// IE 8- don't enum bug keys
+module.exports = (
+ 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
+).split(',');
+
+
+/***/ }),
+/* 28 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var def = __webpack_require__(5).f;
+var has = __webpack_require__(8);
+var TAG = __webpack_require__(0)('toStringTag');
+
+module.exports = function (it, tag, stat) {
+ if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });
+};
+
+
+/***/ }),
+/* 29 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 7.1.13 ToObject(argument)
+var defined = __webpack_require__(11);
+module.exports = function (it) {
+ return Object(defined(it));
+};
+
+
+/***/ }),
+/* 30 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_freeGlobal.js
+var _freeGlobal = __webpack_require__(64);
+
+// CONCATENATED MODULE: ./node_modules/lodash-es/_root.js
+
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = _freeGlobal["a" /* default */] || freeSelf || Function('return this')();
+
+/* harmony default export */ var _root = (root);
+
+// CONCATENATED MODULE: ./node_modules/lodash-es/_Symbol.js
+
+
+/** Built-in value references. */
+var Symbol = _root.Symbol;
+
+/* harmony default export */ var _Symbol = (Symbol);
+
+// CONCATENATED MODULE: ./node_modules/lodash-es/_getRawTag.js
+
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var _getRawTag_hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString = objectProto.toString;
+
+/** Built-in value references. */
+var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;
+
+/**
+ * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the raw `toStringTag`.
+ */
+function getRawTag(value) {
+ var isOwn = _getRawTag_hasOwnProperty.call(value, symToStringTag),
+ tag = value[symToStringTag];
+
+ try {
+ value[symToStringTag] = undefined;
+ var unmasked = true;
+ } catch (e) {}
+
+ var result = nativeObjectToString.call(value);
+ if (unmasked) {
+ if (isOwn) {
+ value[symToStringTag] = tag;
+ } else {
+ delete value[symToStringTag];
+ }
+ }
+ return result;
+}
+
+/* harmony default export */ var _getRawTag = (getRawTag);
+
+// CONCATENATED MODULE: ./node_modules/lodash-es/_objectToString.js
+/** Used for built-in method references. */
+var _objectToString_objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var _objectToString_nativeObjectToString = _objectToString_objectProto.toString;
+
+/**
+ * Converts `value` to a string using `Object.prototype.toString`.
+ *
+ * @private
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ */
+function objectToString(value) {
+ return _objectToString_nativeObjectToString.call(value);
+}
+
+/* harmony default export */ var _objectToString = (objectToString);
+
+// CONCATENATED MODULE: ./node_modules/lodash-es/_baseGetTag.js
+
+
+
+
+/** `Object#toString` result references. */
+var nullTag = '[object Null]',
+ undefinedTag = '[object Undefined]';
+
+/** Built-in value references. */
+var _baseGetTag_symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;
+
+/**
+ * The base implementation of `getTag` without fallbacks for buggy environments.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag(value) {
+ if (value == null) {
+ return value === undefined ? undefinedTag : nullTag;
+ }
+ return (_baseGetTag_symToStringTag && _baseGetTag_symToStringTag in Object(value))
+ ? _getRawTag(value)
+ : _objectToString(value);
+}
+
+/* harmony default export */ var _baseGetTag = (baseGetTag);
+
+// CONCATENATED MODULE: ./node_modules/lodash-es/_overArg.js
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg(func, transform) {
+ return function(arg) {
+ return func(transform(arg));
+ };
+}
+
+/* harmony default export */ var _overArg = (overArg);
+
+// CONCATENATED MODULE: ./node_modules/lodash-es/_getPrototype.js
+
+
+/** Built-in value references. */
+var getPrototype = _overArg(Object.getPrototypeOf, Object);
+
+/* harmony default export */ var _getPrototype = (getPrototype);
+
+// CONCATENATED MODULE: ./node_modules/lodash-es/isObjectLike.js
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+ return value != null && typeof value == 'object';
+}
+
+/* harmony default export */ var lodash_es_isObjectLike = (isObjectLike);
+
+// CONCATENATED MODULE: ./node_modules/lodash-es/isPlainObject.js
+
+
+
+
+/** `Object#toString` result references. */
+var objectTag = '[object Object]';
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+ isPlainObject_objectProto = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var isPlainObject_hasOwnProperty = isPlainObject_objectProto.hasOwnProperty;
+
+/** Used to infer the `Object` constructor. */
+var objectCtorString = funcToString.call(Object);
+
+/**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * `Object` constructor or one with a `[[Prototype]]` of `null`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.8.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * }
+ *
+ * _.isPlainObject(new Foo);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ *
+ * _.isPlainObject(Object.create(null));
+ * // => true
+ */
+function isPlainObject(value) {
+ if (!lodash_es_isObjectLike(value) || _baseGetTag(value) != objectTag) {
+ return false;
+ }
+ var proto = _getPrototype(value);
+ if (proto === null) {
+ return true;
+ }
+ var Ctor = isPlainObject_hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+ return typeof Ctor == 'function' && Ctor instanceof Ctor &&
+ funcToString.call(Ctor) == objectCtorString;
+}
+
+/* harmony default export */ var lodash_es_isPlainObject = (isPlainObject);
+
+// EXTERNAL MODULE: ./node_modules/symbol-observable/index.js
+var symbol_observable = __webpack_require__(65);
+var symbol_observable_default = /*#__PURE__*/__webpack_require__.n(symbol_observable);
+
+// CONCATENATED MODULE: ./node_modules/redux/es/createStore.js
+
+
+
+/**
+ * These are private action types reserved by Redux.
+ * For any unknown actions, you must return the current state.
+ * If the current state is undefined, you must return the initial state.
+ * Do not reference these action types directly in your code.
+ */
+var ActionTypes = {
+ INIT: '@@redux/INIT'
+
+ /**
+ * Creates a Redux store that holds the state tree.
+ * The only way to change the data in the store is to call `dispatch()` on it.
+ *
+ * There should only be a single store in your app. To specify how different
+ * parts of the state tree respond to actions, you may combine several reducers
+ * into a single reducer function by using `combineReducers`.
+ *
+ * @param {Function} reducer A function that returns the next state tree, given
+ * the current state tree and the action to handle.
+ *
+ * @param {any} [preloadedState] The initial state. You may optionally specify it
+ * to hydrate the state from the server in universal apps, or to restore a
+ * previously serialized user session.
+ * If you use `combineReducers` to produce the root reducer function, this must be
+ * an object with the same shape as `combineReducers` keys.
+ *
+ * @param {Function} [enhancer] The store enhancer. You may optionally specify it
+ * to enhance the store with third-party capabilities such as middleware,
+ * time travel, persistence, etc. The only store enhancer that ships with Redux
+ * is `applyMiddleware()`.
+ *
+ * @returns {Store} A Redux store that lets you read the state, dispatch actions
+ * and subscribe to changes.
+ */
+};function createStore_createStore(reducer, preloadedState, enhancer) {
+ var _ref2;
+
+ if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
+ enhancer = preloadedState;
+ preloadedState = undefined;
+ }
+
+ if (typeof enhancer !== 'undefined') {
+ if (typeof enhancer !== 'function') {
+ throw new Error('Expected the enhancer to be a function.');
+ }
+
+ return enhancer(createStore_createStore)(reducer, preloadedState);
+ }
+
+ if (typeof reducer !== 'function') {
+ throw new Error('Expected the reducer to be a function.');
+ }
+
+ var currentReducer = reducer;
+ var currentState = preloadedState;
+ var currentListeners = [];
+ var nextListeners = currentListeners;
+ var isDispatching = false;
+
+ function ensureCanMutateNextListeners() {
+ if (nextListeners === currentListeners) {
+ nextListeners = currentListeners.slice();
+ }
+ }
+
+ /**
+ * Reads the state tree managed by the store.
+ *
+ * @returns {any} The current state tree of your application.
+ */
+ function getState() {
+ return currentState;
+ }
+
+ /**
+ * Adds a change listener. It will be called any time an action is dispatched,
+ * and some part of the state tree may potentially have changed. You may then
+ * call `getState()` to read the current state tree inside the callback.
+ *
+ * You may call `dispatch()` from a change listener, with the following
+ * caveats:
+ *
+ * 1. The subscriptions are snapshotted just before every `dispatch()` call.
+ * If you subscribe or unsubscribe while the listeners are being invoked, this
+ * will not have any effect on the `dispatch()` that is currently in progress.
+ * However, the next `dispatch()` call, whether nested or not, will use a more
+ * recent snapshot of the subscription list.
+ *
+ * 2. The listener should not expect to see all state changes, as the state
+ * might have been updated multiple times during a nested `dispatch()` before
+ * the listener is called. It is, however, guaranteed that all subscribers
+ * registered before the `dispatch()` started will be called with the latest
+ * state by the time it exits.
+ *
+ * @param {Function} listener A callback to be invoked on every dispatch.
+ * @returns {Function} A function to remove this change listener.
+ */
+ function subscribe(listener) {
+ if (typeof listener !== 'function') {
+ throw new Error('Expected listener to be a function.');
+ }
+
+ var isSubscribed = true;
+
+ ensureCanMutateNextListeners();
+ nextListeners.push(listener);
+
+ return function unsubscribe() {
+ if (!isSubscribed) {
+ return;
+ }
+
+ isSubscribed = false;
+
+ ensureCanMutateNextListeners();
+ var index = nextListeners.indexOf(listener);
+ nextListeners.splice(index, 1);
+ };
+ }
+
+ /**
+ * Dispatches an action. It is the only way to trigger a state change.
+ *
+ * The `reducer` function, used to create the store, will be called with the
+ * current state tree and the given `action`. Its return value will
+ * be considered the **next** state of the tree, and the change listeners
+ * will be notified.
+ *
+ * The base implementation only supports plain object actions. If you want to
+ * dispatch a Promise, an Observable, a thunk, or something else, you need to
+ * wrap your store creating function into the corresponding middleware. For
+ * example, see the documentation for the `redux-thunk` package. Even the
+ * middleware will eventually dispatch plain object actions using this method.
+ *
+ * @param {Object} action A plain object representing “what changed”. It is
+ * a good idea to keep actions serializable so you can record and replay user
+ * sessions, or use the time travelling `redux-devtools`. An action must have
+ * a `type` property which may not be `undefined`. It is a good idea to use
+ * string constants for action types.
+ *
+ * @returns {Object} For convenience, the same action object you dispatched.
+ *
+ * Note that, if you use a custom middleware, it may wrap `dispatch()` to
+ * return something else (for example, a Promise you can await).
+ */
+ function dispatch(action) {
+ if (!lodash_es_isPlainObject(action)) {
+ throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');
+ }
+
+ if (typeof action.type === 'undefined') {
+ throw new Error('Actions may not have an undefined "type" property. ' + 'Have you misspelled a constant?');
+ }
+
+ if (isDispatching) {
+ throw new Error('Reducers may not dispatch actions.');
+ }
+
+ try {
+ isDispatching = true;
+ currentState = currentReducer(currentState, action);
+ } finally {
+ isDispatching = false;
+ }
+
+ var listeners = currentListeners = nextListeners;
+ for (var i = 0; i < listeners.length; i++) {
+ var listener = listeners[i];
+ listener();
+ }
+
+ return action;
+ }
+
+ /**
+ * Replaces the reducer currently used by the store to calculate the state.
+ *
+ * You might need this if your app implements code splitting and you want to
+ * load some of the reducers dynamically. You might also need this if you
+ * implement a hot reloading mechanism for Redux.
+ *
+ * @param {Function} nextReducer The reducer for the store to use instead.
+ * @returns {void}
+ */
+ function replaceReducer(nextReducer) {
+ if (typeof nextReducer !== 'function') {
+ throw new Error('Expected the nextReducer to be a function.');
+ }
+
+ currentReducer = nextReducer;
+ dispatch({ type: ActionTypes.INIT });
+ }
+
+ /**
+ * Interoperability point for observable/reactive libraries.
+ * @returns {observable} A minimal observable of state changes.
+ * For more information, see the observable proposal:
+ * https://github.com/tc39/proposal-observable
+ */
+ function observable() {
+ var _ref;
+
+ var outerSubscribe = subscribe;
+ return _ref = {
+ /**
+ * The minimal observable subscription method.
+ * @param {Object} observer Any object that can be used as an observer.
+ * The observer object should have a `next` method.
+ * @returns {subscription} An object with an `unsubscribe` method that can
+ * be used to unsubscribe the observable from the store, and prevent further
+ * emission of values from the observable.
+ */
+ subscribe: function subscribe(observer) {
+ if (typeof observer !== 'object') {
+ throw new TypeError('Expected the observer to be an object.');
+ }
+
+ function observeState() {
+ if (observer.next) {
+ observer.next(getState());
+ }
+ }
+
+ observeState();
+ var unsubscribe = outerSubscribe(observeState);
+ return { unsubscribe: unsubscribe };
+ }
+ }, _ref[symbol_observable_default.a] = function () {
+ return this;
+ }, _ref;
+ }
+
+ // When a store is created, an "INIT" action is dispatched so that every
+ // reducer returns their initial state. This effectively populates
+ // the initial state tree.
+ dispatch({ type: ActionTypes.INIT });
+
+ return _ref2 = {
+ dispatch: dispatch,
+ subscribe: subscribe,
+ getState: getState,
+ replaceReducer: replaceReducer
+ }, _ref2[symbol_observable_default.a] = observable, _ref2;
+}
+// CONCATENATED MODULE: ./node_modules/redux/es/utils/warning.js
+/**
+ * Prints a warning in the console if it exists.
+ *
+ * @param {String} message The warning message.
+ * @returns {void}
+ */
+function warning_warning(message) {
+ /* eslint-disable no-console */
+ if (typeof console !== 'undefined' && typeof console.error === 'function') {
+ console.error(message);
+ }
+ /* eslint-enable no-console */
+ try {
+ // This error was thrown as a convenience so that if you enable
+ // "break on all exceptions" in your console,
+ // it would pause the execution at this line.
+ throw new Error(message);
+ /* eslint-disable no-empty */
+ } catch (e) {}
+ /* eslint-enable no-empty */
+}
+// CONCATENATED MODULE: ./node_modules/redux/es/combineReducers.js
+
+
+
+
+function getUndefinedStateErrorMessage(key, action) {
+ var actionType = action && action.type;
+ var actionName = actionType && '"' + actionType.toString() + '"' || 'an action';
+
+ return 'Given action ' + actionName + ', reducer "' + key + '" returned undefined. ' + 'To ignore an action, you must explicitly return the previous state. ' + 'If you want this reducer to hold no value, you can return null instead of undefined.';
+}
+
+function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
+ var reducerKeys = Object.keys(reducers);
+ var argumentName = action && action.type === ActionTypes.INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer';
+
+ if (reducerKeys.length === 0) {
+ return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.';
+ }
+
+ if (!lodash_es_isPlainObject(inputState)) {
+ return 'The ' + argumentName + ' has unexpected type of "' + {}.toString.call(inputState).match(/\s([a-z|A-Z]+)/)[1] + '". Expected argument to be an object with the following ' + ('keys: "' + reducerKeys.join('", "') + '"');
+ }
+
+ var unexpectedKeys = Object.keys(inputState).filter(function (key) {
+ return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key];
+ });
+
+ unexpectedKeys.forEach(function (key) {
+ unexpectedKeyCache[key] = true;
+ });
+
+ if (unexpectedKeys.length > 0) {
+ return 'Unexpected ' + (unexpectedKeys.length > 1 ? 'keys' : 'key') + ' ' + ('"' + unexpectedKeys.join('", "') + '" found in ' + argumentName + '. ') + 'Expected to find one of the known reducer keys instead: ' + ('"' + reducerKeys.join('", "') + '". Unexpected keys will be ignored.');
+ }
+}
+
+function assertReducerShape(reducers) {
+ Object.keys(reducers).forEach(function (key) {
+ var reducer = reducers[key];
+ var initialState = reducer(undefined, { type: ActionTypes.INIT });
+
+ if (typeof initialState === 'undefined') {
+ throw new Error('Reducer "' + key + '" returned undefined during initialization. ' + 'If the state passed to the reducer is undefined, you must ' + 'explicitly return the initial state. The initial state may ' + 'not be undefined. If you don\'t want to set a value for this reducer, ' + 'you can use null instead of undefined.');
+ }
+
+ var type = '@@redux/PROBE_UNKNOWN_ACTION_' + Math.random().toString(36).substring(7).split('').join('.');
+ if (typeof reducer(undefined, { type: type }) === 'undefined') {
+ throw new Error('Reducer "' + key + '" returned undefined when probed with a random type. ' + ('Don\'t try to handle ' + ActionTypes.INIT + ' or other actions in "redux/*" ') + 'namespace. They are considered private. Instead, you must return the ' + 'current state for any unknown actions, unless it is undefined, ' + 'in which case you must return the initial state, regardless of the ' + 'action type. The initial state may not be undefined, but can be null.');
+ }
+ });
+}
+
+/**
+ * Turns an object whose values are different reducer functions, into a single
+ * reducer function. It will call every child reducer, and gather their results
+ * into a single state object, whose keys correspond to the keys of the passed
+ * reducer functions.
+ *
+ * @param {Object} reducers An object whose values correspond to different
+ * reducer functions that need to be combined into one. One handy way to obtain
+ * it is to use ES6 `import * as reducers` syntax. The reducers may never return
+ * undefined for any action. Instead, they should return their initial state
+ * if the state passed to them was undefined, and the current state for any
+ * unrecognized action.
+ *
+ * @returns {Function} A reducer function that invokes every reducer inside the
+ * passed object, and builds a state object with the same shape.
+ */
+function combineReducers(reducers) {
+ var reducerKeys = Object.keys(reducers);
+ var finalReducers = {};
+ for (var i = 0; i < reducerKeys.length; i++) {
+ var key = reducerKeys[i];
+
+ if (false) {
+ if (typeof reducers[key] === 'undefined') {
+ warning('No reducer provided for key "' + key + '"');
+ }
+ }
+
+ if (typeof reducers[key] === 'function') {
+ finalReducers[key] = reducers[key];
+ }
+ }
+ var finalReducerKeys = Object.keys(finalReducers);
+
+ var unexpectedKeyCache = void 0;
+ if (false) {
+ unexpectedKeyCache = {};
+ }
+
+ var shapeAssertionError = void 0;
+ try {
+ assertReducerShape(finalReducers);
+ } catch (e) {
+ shapeAssertionError = e;
+ }
+
+ return function combination() {
+ var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+ var action = arguments[1];
+
+ if (shapeAssertionError) {
+ throw shapeAssertionError;
+ }
+
+ if (false) {
+ var warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache);
+ if (warningMessage) {
+ warning(warningMessage);
+ }
+ }
+
+ var hasChanged = false;
+ var nextState = {};
+ for (var _i = 0; _i < finalReducerKeys.length; _i++) {
+ var _key = finalReducerKeys[_i];
+ var reducer = finalReducers[_key];
+ var previousStateForKey = state[_key];
+ var nextStateForKey = reducer(previousStateForKey, action);
+ if (typeof nextStateForKey === 'undefined') {
+ var errorMessage = getUndefinedStateErrorMessage(_key, action);
+ throw new Error(errorMessage);
+ }
+ nextState[_key] = nextStateForKey;
+ hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
+ }
+ return hasChanged ? nextState : state;
+ };
+}
+// CONCATENATED MODULE: ./node_modules/redux/es/bindActionCreators.js
+function bindActionCreator(actionCreator, dispatch) {
+ return function () {
+ return dispatch(actionCreator.apply(undefined, arguments));
+ };
+}
+
+/**
+ * Turns an object whose values are action creators, into an object with the
+ * same keys, but with every function wrapped into a `dispatch` call so they
+ * may be invoked directly. This is just a convenience method, as you can call
+ * `store.dispatch(MyActionCreators.doSomething())` yourself just fine.
+ *
+ * For convenience, you can also pass a single function as the first argument,
+ * and get a function in return.
+ *
+ * @param {Function|Object} actionCreators An object whose values are action
+ * creator functions. One handy way to obtain it is to use ES6 `import * as`
+ * syntax. You may also pass a single function.
+ *
+ * @param {Function} dispatch The `dispatch` function available on your Redux
+ * store.
+ *
+ * @returns {Function|Object} The object mimicking the original object, but with
+ * every action creator wrapped into the `dispatch` call. If you passed a
+ * function as `actionCreators`, the return value will also be a single
+ * function.
+ */
+function bindActionCreators(actionCreators, dispatch) {
+ if (typeof actionCreators === 'function') {
+ return bindActionCreator(actionCreators, dispatch);
+ }
+
+ if (typeof actionCreators !== 'object' || actionCreators === null) {
+ throw new Error('bindActionCreators expected an object or a function, instead received ' + (actionCreators === null ? 'null' : typeof actionCreators) + '. ' + 'Did you write "import ActionCreators from" instead of "import * as ActionCreators from"?');
+ }
+
+ var keys = Object.keys(actionCreators);
+ var boundActionCreators = {};
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ var actionCreator = actionCreators[key];
+ if (typeof actionCreator === 'function') {
+ boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);
+ }
+ }
+ return boundActionCreators;
+}
+// CONCATENATED MODULE: ./node_modules/redux/es/compose.js
+/**
+ * Composes single-argument functions from right to left. The rightmost
+ * function can take multiple arguments as it provides the signature for
+ * the resulting composite function.
+ *
+ * @param {...Function} funcs The functions to compose.
+ * @returns {Function} A function obtained by composing the argument functions
+ * from right to left. For example, compose(f, g, h) is identical to doing
+ * (...args) => f(g(h(...args))).
+ */
+
+function compose() {
+ for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
+ funcs[_key] = arguments[_key];
+ }
+
+ if (funcs.length === 0) {
+ return function (arg) {
+ return arg;
+ };
+ }
+
+ if (funcs.length === 1) {
+ return funcs[0];
+ }
+
+ return funcs.reduce(function (a, b) {
+ return function () {
+ return a(b.apply(undefined, arguments));
+ };
+ });
+}
+// CONCATENATED MODULE: ./node_modules/redux/es/applyMiddleware.js
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+
+
+/**
+ * Creates a store enhancer that applies middleware to the dispatch method
+ * of the Redux store. This is handy for a variety of tasks, such as expressing
+ * asynchronous actions in a concise manner, or logging every action payload.
+ *
+ * See `redux-thunk` package as an example of the Redux middleware.
+ *
+ * Because middleware is potentially asynchronous, this should be the first
+ * store enhancer in the composition chain.
+ *
+ * Note that each middleware will be given the `dispatch` and `getState` functions
+ * as named arguments.
+ *
+ * @param {...Function} middlewares The middleware chain to be applied.
+ * @returns {Function} A store enhancer applying the middleware.
+ */
+function applyMiddleware() {
+ for (var _len = arguments.length, middlewares = Array(_len), _key = 0; _key < _len; _key++) {
+ middlewares[_key] = arguments[_key];
+ }
+
+ return function (createStore) {
+ return function (reducer, preloadedState, enhancer) {
+ var store = createStore(reducer, preloadedState, enhancer);
+ var _dispatch = store.dispatch;
+ var chain = [];
+
+ var middlewareAPI = {
+ getState: store.getState,
+ dispatch: function dispatch(action) {
+ return _dispatch(action);
+ }
+ };
+ chain = middlewares.map(function (middleware) {
+ return middleware(middlewareAPI);
+ });
+ _dispatch = compose.apply(undefined, chain)(store.dispatch);
+
+ return _extends({}, store, {
+ dispatch: _dispatch
+ });
+ };
+ };
+}
+// CONCATENATED MODULE: ./node_modules/redux/es/index.js
+/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, "createStore", function() { return createStore_createStore; });
+/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, "combineReducers", function() { return combineReducers; });
+/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, "bindActionCreators", function() { return bindActionCreators; });
+/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, "applyMiddleware", function() { return applyMiddleware; });
+/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, "compose", function() { return compose; });
+
+
+
+
+
+
+
+/*
+* This is a dummy function to check if the function name has been altered by minification.
+* If the function has been minified and NODE_ENV !== 'production', warn the user.
+*/
+function isCrushed() {}
+
+if (false) {
+ warning('You are currently using minified code outside of NODE_ENV === \'production\'. ' + 'This means that you are running a slower development build of Redux. ' + 'You can use loose-envify (https://github.com/zertosh/loose-envify) for browserify ' + 'or DefinePlugin for webpack (http://stackoverflow.com/questions/30030031) ' + 'to ensure you have the correct code for your production build.');
+}
+
+
+
+/***/ }),
+/* 31 */
+/***/ (function(module, exports) {
+
+var g;
+
+// This works in non-strict mode
+g = (function() {
+ return this;
+})();
+
+try {
+ // This works if eval is allowed (see CSP)
+ g = g || Function("return this")() || (1,eval)("this");
+} catch(e) {
+ // This works if the window reference is available
+ if(typeof window === "object")
+ g = window;
+}
+
+// g can still be undefined, but nothing to do about it...
+// We return undefined, instead of nothing here, so it's
+// easier to handle this case. if(!global) { ...}
+
+module.exports = g;
+
+
+/***/ }),
+/* 32 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _utils = __webpack_require__(1);
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var WrappedElement = function () {
+ function WrappedElement(_ref) {
+ var element = _ref.element,
+ classNames = _ref.classNames;
+
+ _classCallCheck(this, WrappedElement);
+
+ Object.assign(this, { element: element, classNames: classNames });
+
+ if (!(0, _utils.isElement)(element)) {
+ throw new TypeError('Invalid element passed');
+ }
+
+ this.isDisabled = false;
+ }
+
+ _createClass(WrappedElement, [{
+ key: 'conceal',
+ value: function conceal() {
+ // Hide passed input
+ this.element.classList.add(this.classNames.input, this.classNames.hiddenState);
+
+ // Remove element from tab index
+ this.element.tabIndex = '-1';
+
+ // Backup original styles if any
+ var origStyle = this.element.getAttribute('style');
+
+ if (origStyle) {
+ this.element.setAttribute('data-choice-orig-style', origStyle);
+ }
+
+ this.element.setAttribute('aria-hidden', 'true');
+ this.element.setAttribute('data-choice', 'active');
+ }
+ }, {
+ key: 'reveal',
+ value: function reveal() {
+ // Reinstate passed element
+ this.element.classList.remove(this.classNames.input, this.classNames.hiddenState);
+ this.element.removeAttribute('tabindex');
+
+ // Recover original styles if any
+ var origStyle = this.element.getAttribute('data-choice-orig-style');
+
+ if (origStyle) {
+ this.element.removeAttribute('data-choice-orig-style');
+ this.element.setAttribute('style', origStyle);
+ } else {
+ this.element.removeAttribute('style');
+ }
+ this.element.removeAttribute('aria-hidden');
+ this.element.removeAttribute('data-choice');
+
+ // Re-assign values - this is weird, I know
+ this.element.value = this.element.value;
+ }
+ }, {
+ key: 'enable',
+ value: function enable() {
+ this.element.removeAttribute('disabled');
+ this.element.disabled = false;
+ this.isDisabled = false;
+ }
+ }, {
+ key: 'disable',
+ value: function disable() {
+ this.element.setAttribute('disabled', '');
+ this.element.disabled = true;
+ this.isDisabled = true;
+ }
+ }, {
+ key: 'triggerEvent',
+ value: function triggerEvent(eventType, data) {
+ (0, _utils.dispatchEvent)(this.element, eventType, data);
+ }
+ }, {
+ key: 'value',
+ get: function get() {
+ return this.element.value;
+ }
+ }]);
+
+ return WrappedElement;
+}();
+
+exports.default = WrappedElement;
+
+/***/ }),
+/* 33 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.TEMPLATES = undefined;
+
+var _classnames = __webpack_require__(80);
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _utils = __webpack_require__(1);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var TEMPLATES = exports.TEMPLATES = {
+ containerOuter: function containerOuter(globalClasses, direction, isSelectElement, isSelectOneElement, searchEnabled, passedElementType) {
+ var tabIndex = isSelectOneElement ? 'tabindex="0"' : '';
+ var role = isSelectElement ? 'role="listbox"' : '';
+ var ariaAutoComplete = '';
+
+ if (isSelectElement && searchEnabled) {
+ role = 'role="combobox"';
+ ariaAutoComplete = 'aria-autocomplete="list"';
+ }
+
+ return (0, _utils.strToEl)('\n \n
\n ');
+ },
+ containerInner: function containerInner(globalClasses) {
+ return (0, _utils.strToEl)('\n \n ');
+ },
+ itemList: function itemList(globalClasses, isSelectOneElement) {
+ var _classNames;
+
+ var localClasses = (0, _classnames2.default)(globalClasses.list, (_classNames = {}, _defineProperty(_classNames, globalClasses.listSingle, isSelectOneElement), _defineProperty(_classNames, globalClasses.listItems, !isSelectOneElement), _classNames));
+
+ return (0, _utils.strToEl)('\n \n ');
+ },
+ placeholder: function placeholder(globalClasses, value) {
+ return (0, _utils.strToEl)('\n \n ' + value + '\n
\n ');
+ },
+ item: function item(globalClasses, data, removeItemButton) {
+ var _classNames2;
+
+ var ariaSelected = data.active ? 'aria-selected="true"' : '';
+ var ariaDisabled = data.disabled ? 'aria-disabled="true"' : '';
+
+ var localClasses = (0, _classnames2.default)(globalClasses.item, (_classNames2 = {}, _defineProperty(_classNames2, globalClasses.highlightedState, data.highlighted), _defineProperty(_classNames2, globalClasses.itemSelectable, !data.highlighted), _defineProperty(_classNames2, globalClasses.placeholder, data.placeholder), _classNames2));
+
+ if (removeItemButton) {
+ var _classNames3;
+
+ localClasses = (0, _classnames2.default)(globalClasses.item, (_classNames3 = {}, _defineProperty(_classNames3, globalClasses.highlightedState, data.highlighted), _defineProperty(_classNames3, globalClasses.itemSelectable, !data.disabled), _defineProperty(_classNames3, globalClasses.placeholder, data.placeholder), _classNames3));
+
+ return (0, _utils.strToEl)('\n \n ' + data.label + '\n
\n ');
+ }
+
+ return (0, _utils.strToEl)('\n \n ' + data.label + '\n
\n ');
+ },
+ choiceList: function choiceList(globalClasses, isSelectOneElement) {
+ var ariaMultiSelectable = !isSelectOneElement ? 'aria-multiselectable="true"' : '';
+
+ return (0, _utils.strToEl)('\n \n
\n ');
+ },
+ choiceGroup: function choiceGroup(globalClasses, data) {
+ var ariaDisabled = data.disabled ? 'aria-disabled="true"' : '';
+ var localClasses = (0, _classnames2.default)(globalClasses.group, _defineProperty({}, globalClasses.itemDisabled, data.disabled));
+
+ return (0, _utils.strToEl)('\n \n ');
+ },
+ choice: function choice(globalClasses, data, itemSelectText) {
+ var _classNames5;
+
+ var role = data.groupId > 0 ? 'role="treeitem"' : 'role="option"';
+ var localClasses = (0, _classnames2.default)(globalClasses.item, globalClasses.itemChoice, (_classNames5 = {}, _defineProperty(_classNames5, globalClasses.itemDisabled, data.disabled), _defineProperty(_classNames5, globalClasses.itemSelectable, !data.disabled), _defineProperty(_classNames5, globalClasses.placeholder, data.placeholder), _classNames5));
+
+ return (0, _utils.strToEl)('\n \n ' + data.label + '\n
\n ');
+ },
+ input: function input(globalClasses) {
+ var localClasses = (0, _classnames2.default)(globalClasses.input, globalClasses.inputCloned);
+
+ return (0, _utils.strToEl)('\n \n ');
+ },
+ dropdown: function dropdown(globalClasses) {
+ var localClasses = (0, _classnames2.default)(globalClasses.list, globalClasses.listDropdown);
+
+ return (0, _utils.strToEl)('\n \n
\n ');
+ },
+ notice: function notice(globalClasses, label) {
+ var _classNames6;
+
+ var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+
+ var localClasses = (0, _classnames2.default)(globalClasses.item, globalClasses.itemChoice, (_classNames6 = {}, _defineProperty(_classNames6, globalClasses.noResults, type === 'no-results'), _defineProperty(_classNames6, globalClasses.noChoices, type === 'no-choices'), _classNames6));
+
+ return (0, _utils.strToEl)('\n \n ' + label + '\n
\n ');
+ },
+ option: function option(data) {
+ return (0, _utils.strToEl)('\n \n ');
+ }
+};
+
+exports.default = TEMPLATES;
+
+/***/ }),
+/* 34 */
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(35);
+
+
+/***/ }),
+/* 35 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _fuse = __webpack_require__(36);
+
+var _fuse2 = _interopRequireDefault(_fuse);
+
+__webpack_require__(37);
+
+var _store = __webpack_require__(63);
+
+var _store2 = _interopRequireDefault(_store);
+
+var _components = __webpack_require__(73);
+
+var _constants = __webpack_require__(9);
+
+var _templates = __webpack_require__(33);
+
+var _choices = __webpack_require__(81);
+
+var _items = __webpack_require__(82);
+
+var _groups = __webpack_require__(83);
+
+var _misc = __webpack_require__(84);
+
+var _utils = __webpack_require__(1);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+/**
+ * Choices
+ */
+var Choices = function () {
+ function Choices() {
+ var element = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '[data-choice]';
+ var userConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+ _classCallCheck(this, Choices);
+
+ if ((0, _utils.isType)('String', element)) {
+ var elements = Array.from(document.querySelectorAll(element));
+
+ // If there are multiple elements, create a new instance
+ // for each element besides the first one (as that already has an instance)
+ if (elements.length > 1) {
+ return this._generateInstances(elements, userConfig);
+ }
+ }
+
+ this.config = Choices._generateConfig(userConfig);
+
+ if (!['auto', 'always'].includes(this.config.renderSelectedChoices)) {
+ this.config.renderSelectedChoices = 'auto';
+ }
+
+ // Create data store
+ this._store = new _store2.default(this.render);
+
+ // State tracking
+ this.initialised = false;
+ this._currentState = {};
+ this._prevState = {};
+ this._currentValue = '';
+ this._isScrollingOnIe = false;
+ this._wasTap = true;
+
+ // Retrieve triggering element (i.e. element with 'data-choice' trigger)
+ var passedElement = (0, _utils.isType)('String', element) ? document.querySelector(element) : element;
+
+ this._isTextElement = passedElement.type === 'text';
+ this._isSelectOneElement = passedElement.type === 'select-one';
+ this._isSelectMultipleElement = passedElement.type === 'select-multiple';
+ this._isSelectElement = this._isSelectOneElement || this._isSelectMultipleElement;
+
+ if (this._isTextElement) {
+ this.passedElement = new _components.WrappedInput({
+ element: passedElement,
+ classNames: this.config.classNames,
+ delimiter: this.config.delimiter
+ });
+ } else if (this._isSelectElement) {
+ this.passedElement = new _components.WrappedSelect({
+ element: passedElement,
+ classNames: this.config.classNames
+ });
+ }
+
+ if (!this.passedElement) {
+ throw new Error('Could not wrap passed element');
+ }
+
+ if (this.config.shouldSortItems === true && this._isSelectOneElement && !this.config.silent) {
+ console.warn('shouldSortElements: Type of passed element is \'select-one\', falling back to false.');
+ }
+
+ this._highlightPosition = 0;
+ this._placeholderValue = this._generatePlaceholderValue();
+
+ // Assign preset choices from passed object
+ this._presetChoices = this.config.choices;
+ // Assign preset items from passed object first
+ this._presetItems = this.config.items;
+
+ // Then add any values passed from attribute
+ if (this.passedElement.value) {
+ this._presetItems = this._presetItems.concat(this.passedElement.value.split(this.config.delimiter));
+ }
+
+ this._baseId = (0, _utils.generateId)(this.passedElement.element, 'choices-');
+ this._idNames = {
+ itemChoice: 'item-choice'
+ };
+
+ this.render = this.render.bind(this);
+ this._onFocus = this._onFocus.bind(this);
+ this._onBlur = this._onBlur.bind(this);
+ this._onKeyUp = this._onKeyUp.bind(this);
+ this._onKeyDown = this._onKeyDown.bind(this);
+ this._onClick = this._onClick.bind(this);
+ this._onTouchMove = this._onTouchMove.bind(this);
+ this._onTouchEnd = this._onTouchEnd.bind(this);
+ this._onMouseDown = this._onMouseDown.bind(this);
+ this._onMouseOver = this._onMouseOver.bind(this);
+
+ // If element has already been initialised with Choices, fail silently
+ if (this.passedElement.element.getAttribute('data-choice') === 'active') {
+ return false;
+ }
+
+ // Let's go
+ this.init();
+ }
+
+ /* ========================================
+ = Public functions =
+ ======================================== */
+
+ /**
+ * Initialise Choices
+ * @return
+ * @public
+ */
+
+
+ _createClass(Choices, [{
+ key: 'init',
+ value: function init() {
+ if (this.initialised) {
+ return;
+ }
+
+ // Set initialise flag
+ this.initialised = true;
+ // Create required templates
+ this._createTemplates();
+ // Create required elements
+ this._createElements();
+ // Generate input markup
+ this._createStructure();
+ // Subscribe store to render method
+ this._store.subscribe(this.render);
+ // Render any items
+ this.render();
+ // Trigger event listeners
+ this._addEventListeners();
+
+ var callbackOnInit = this.config.callbackOnInit;
+ // Run callback if it is a function
+
+ if (callbackOnInit && (0, _utils.isType)('Function', callbackOnInit)) {
+ callbackOnInit.call(this);
+ }
+ }
+
+ /**
+ * Destroy Choices and nullify values
+ * @return
+ * @public
+ */
+
+ }, {
+ key: 'destroy',
+ value: function destroy() {
+ if (!this.initialised) {
+ return;
+ }
+
+ // Remove all event listeners
+ this._removeEventListeners();
+ this.passedElement.reveal();
+ this.containerOuter.unwrap(this.passedElement.element);
+
+ if (this._isSelectElement) {
+ this.passedElement.options = this._presetChoices;
+ }
+
+ // Clear data store
+ this.clearStore();
+
+ // Nullify instance-specific data
+ this.config.templates = null;
+
+ // Uninitialise
+ this.initialised = false;
+ }
+
+ /**
+ * Enable interaction with Choices
+ * @return {Object} Class instance
+ */
+
+ }, {
+ key: 'enable',
+ value: function enable() {
+ if (!this.initialised) {
+ return this;
+ }
+
+ this.passedElement.enable();
+
+ if (this.containerOuter.isDisabled) {
+ this._addEventListeners();
+ this.input.enable();
+ this.containerOuter.enable();
+ }
+
+ return this;
+ }
+
+ /**
+ * Disable interaction with Choices
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'disable',
+ value: function disable() {
+ if (!this.initialised) {
+ return this;
+ }
+
+ this.passedElement.disable();
+
+ if (!this.containerOuter.isDisabled) {
+ this._removeEventListeners();
+ this.input.disable();
+ this.containerOuter.disable();
+ }
+
+ return this;
+ }
+
+ /**
+ * Render DOM with values
+ * @return
+ * @private
+ */
+
+ }, {
+ key: 'render',
+ value: function render() {
+ this._currentState = this._store.state;
+
+ var stateChanged = this._currentState.choices !== this._prevState.choices || this._currentState.groups !== this._prevState.groups || this._currentState.items !== this._prevState.items;
+ var shouldRenderChoices = this._isSelectElement;
+ var shouldRenderItems = this._currentState.items !== this._prevState.items;
+
+ if (!stateChanged) {
+ return;
+ }
+
+ if (shouldRenderChoices) {
+ this._renderChoices();
+ }
+
+ if (shouldRenderItems) {
+ this._renderItems();
+ }
+
+ this._prevState = this._currentState;
+ }
+
+ /**
+ * Select item (a selected item can be deleted)
+ * @param {Element} item Element to select
+ * @param {Boolean} [runEvent=true] Whether to trigger 'highlightItem' event
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'highlightItem',
+ value: function highlightItem(item) {
+ var runEvent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+ if (!item) {
+ return this;
+ }
+
+ var id = item.id,
+ _item$groupId = item.groupId,
+ groupId = _item$groupId === undefined ? -1 : _item$groupId,
+ _item$value = item.value,
+ value = _item$value === undefined ? '' : _item$value,
+ _item$label = item.label,
+ label = _item$label === undefined ? '' : _item$label;
+
+ var group = groupId >= 0 ? this._store.getGroupById(groupId) : null;
+
+ this._store.dispatch((0, _items.highlightItem)(id, true));
+
+ if (runEvent) {
+ this.passedElement.triggerEvent(_constants.EVENTS.highlightItem, {
+ id: id,
+ value: value,
+ label: label,
+ groupValue: group && group.value ? group.value : null
+ });
+ }
+
+ return this;
+ }
+
+ /**
+ * Deselect item
+ * @param {Element} item Element to de-select
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'unhighlightItem',
+ value: function unhighlightItem(item) {
+ if (!item) {
+ return this;
+ }
+
+ var id = item.id,
+ _item$groupId2 = item.groupId,
+ groupId = _item$groupId2 === undefined ? -1 : _item$groupId2,
+ _item$value2 = item.value,
+ value = _item$value2 === undefined ? '' : _item$value2,
+ _item$label2 = item.label,
+ label = _item$label2 === undefined ? '' : _item$label2;
+
+ var group = groupId >= 0 ? this._store.getGroupById(groupId) : null;
+
+ this._store.dispatch((0, _items.highlightItem)(id, false));
+ this.passedElement.triggerEvent(_constants.EVENTS.highlightItem, {
+ id: id,
+ value: value,
+ label: label,
+ groupValue: group && group.value ? group.value : null
+ });
+
+ return this;
+ }
+
+ /**
+ * Highlight items within store
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'highlightAll',
+ value: function highlightAll() {
+ var _this = this;
+
+ this._store.items.forEach(function (item) {
+ return _this.highlightItem(item);
+ });
+ return this;
+ }
+
+ /**
+ * Deselect items within store
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'unhighlightAll',
+ value: function unhighlightAll() {
+ var _this2 = this;
+
+ this._store.items.forEach(function (item) {
+ return _this2.unhighlightItem(item);
+ });
+ return this;
+ }
+
+ /**
+ * Remove an item from the store by its value
+ * @param {String} value Value to search for
+ * @return {Object} Class instance
+ * @todo Merge with removeActiveItems
+ * @public
+ */
+
+ }, {
+ key: 'removeActiveItemsByValue',
+ value: function removeActiveItemsByValue(value) {
+ var _this3 = this;
+
+ this._store.activeItems.filter(function (item) {
+ return item.value === value;
+ }).forEach(function (item) {
+ return _this3._removeItem(item);
+ });
+
+ return this;
+ }
+
+ /**
+ * Remove all items from store array
+ * @note Removed items are soft deleted
+ * @param {Number} excludedId Optionally exclude item by ID
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'removeActiveItems',
+ value: function removeActiveItems(excludedId) {
+ var _this4 = this;
+
+ this._store.activeItems.filter(function (_ref) {
+ var id = _ref.id;
+ return id !== excludedId;
+ }).forEach(function (item) {
+ return _this4._removeItem(item);
+ });
+
+ return this;
+ }
+
+ /**
+ * Remove all selected items from store
+ * @note Removed items are soft deleted
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'removeHighlightedItems',
+ value: function removeHighlightedItems() {
+ var _this5 = this;
+
+ var runEvent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+ this._store.highlightedActiveItems.forEach(function (item) {
+ _this5._removeItem(item);
+ // If this action was performed by the user
+ // trigger the event
+ if (runEvent) {
+ _this5._triggerChange(item.value);
+ }
+ });
+
+ return this;
+ }
+
+ /**
+ * Show dropdown to user by adding active state class
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'showDropdown',
+ value: function showDropdown(focusInput) {
+ var _this6 = this;
+
+ if (this.dropdown.isActive) {
+ return this;
+ }
+
+ requestAnimationFrame(function () {
+ _this6.dropdown.show();
+ _this6.containerOuter.open(_this6.dropdown.distanceFromTopWindow());
+
+ if (focusInput && _this6.config.searchEnabled) {
+ _this6.input.focus();
+ }
+
+ _this6.passedElement.triggerEvent(_constants.EVENTS.showDropdown, {});
+ });
+
+ return this;
+ }
+
+ /**
+ * Hide dropdown from user
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'hideDropdown',
+ value: function hideDropdown(blurInput) {
+ var _this7 = this;
+
+ if (!this.dropdown.isActive) {
+ return this;
+ }
+
+ requestAnimationFrame(function () {
+ _this7.dropdown.hide();
+ _this7.containerOuter.close();
+
+ if (blurInput && _this7.config.searchEnabled) {
+ _this7.input.removeActiveDescendant();
+ _this7.input.blur();
+ }
+
+ _this7.passedElement.triggerEvent(_constants.EVENTS.hideDropdown, {});
+ });
+
+ return this;
+ }
+
+ /**
+ * Determine whether to hide or show dropdown based on its current state
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'toggleDropdown',
+ value: function toggleDropdown() {
+ if (this.dropdown.isActive) {
+ this.hideDropdown();
+ } else {
+ this.showDropdown(true); // code smell 🤢
+ }
+
+ return this;
+ }
+
+ /**
+ * Get value(s) of input (i.e. inputted items (text) or selected choices (select))
+ * @param {Boolean} valueOnly Get only values of selected items, otherwise return selected items
+ * @return {Array/String} selected value (select-one) or
+ * array of selected items (inputs & select-multiple)
+ * @public
+ */
+
+ }, {
+ key: 'getValue',
+ value: function getValue() {
+ var valueOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+ var values = this._store.activeItems.reduce(function (selectedItems, item) {
+ var itemValue = valueOnly ? item.value : item;
+ selectedItems.push(itemValue);
+ return selectedItems;
+ }, []);
+
+ return this._isSelectOneElement ? values[0] : values;
+ }
+
+ /**
+ * Set value of input. If the input is a select box, a choice will
+ * be created and selected otherwise an item will created directly.
+ * @param {Array} args Array of value objects or value strings
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'setValue',
+ value: function setValue(args) {
+ var _this8 = this;
+
+ if (!this.initialised) {
+ return this;
+ }
+
+ // Convert args to an iterable array
+ var values = [].concat(_toConsumableArray(args));
+ values.forEach(function (value) {
+ return _this8._setChoiceOrItem(value);
+ });
+
+ return this;
+ }
+
+ /**
+ * Select value of select box via the value of an existing choice
+ * @param {Array/String} value An array of strings of a single string
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'setChoiceByValue',
+ value: function setChoiceByValue(value) {
+ var _this9 = this;
+
+ if (!this.initialised || this._isTextElement) {
+ return this;
+ }
+
+ // If only one value has been passed, convert to array
+ var choiceValue = (0, _utils.isType)('Array', value) ? value : [value];
+
+ // Loop through each value and
+ choiceValue.forEach(function (val) {
+ return _this9._findAndSelectChoiceByValue(val);
+ });
+
+ return this;
+ }
+
+ /**
+ * Direct populate choices
+ * @param {Array} choices - Choices to insert
+ * @param {String} value - Name of 'value' property
+ * @param {String} label - Name of 'label' property
+ * @param {Boolean} replaceChoices Whether existing choices should be removed
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'setChoices',
+ value: function setChoices() {
+ var choices = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+ var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+
+ var _this10 = this;
+
+ var label = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+ var replaceChoices = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+
+ if (!this._isSelectElement || !choices.length || !value) {
+ return this;
+ }
+
+ // Clear choices if needed
+ if (replaceChoices) {
+ this._clearChoices();
+ }
+
+ this.containerOuter.removeLoadingState();
+ var addGroupsAndChoices = function addGroupsAndChoices(groupOrChoice) {
+ if (groupOrChoice.choices) {
+ _this10._addGroup(groupOrChoice, groupOrChoice.id || null, value, label);
+ } else {
+ _this10._addChoice(groupOrChoice[value], groupOrChoice[label], groupOrChoice.selected, groupOrChoice.disabled, undefined, groupOrChoice.customProperties, groupOrChoice.placeholder);
+ }
+ };
+
+ choices.forEach(addGroupsAndChoices);
+
+ return this;
+ }
+
+ /**
+ * Clear items,choices and groups
+ * @note Hard delete
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'clearStore',
+ value: function clearStore() {
+ this._store.dispatch((0, _misc.clearAll)());
+ return this;
+ }
+
+ /**
+ * Set value of input to blank
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'clearInput',
+ value: function clearInput() {
+ var shouldSetInputWidth = !this._isSelectOneElement;
+ this.input.clear(shouldSetInputWidth);
+
+ if (!this._isTextElement && this.config.searchEnabled) {
+ this._isSearching = false;
+ this._store.dispatch((0, _choices.activateChoices)(true));
+ }
+
+ return this;
+ }
+
+ /**
+ * Populate options via ajax callback
+ * @param {Function} fn Function that actually makes an AJAX request
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'ajax',
+ value: function ajax(fn) {
+ var _this11 = this;
+
+ if (!this.initialised || !this._isSelectElement || !fn) {
+ return this;
+ }
+
+ requestAnimationFrame(function () {
+ return _this11._handleLoadingState(true);
+ });
+ fn(this._ajaxCallback());
+
+ return this;
+ }
+
+ /* ===== End of Public functions ====== */
+
+ /* =============================================
+ = Private functions =
+ ============================================= */
+
+ /**
+ * Render group choices into a DOM fragment and append to choice list
+ * @param {Array} groups Groups to add to list
+ * @param {Array} choices Choices to add to groups
+ * @param {DocumentFragment} fragment Fragment to add groups and options to (optional)
+ * @return {DocumentFragment} Populated options fragment
+ * @private
+ */
+
+ }, {
+ key: '_createGroupsFragment',
+ value: function _createGroupsFragment(groups, choices, fragment) {
+ var _this12 = this;
+
+ var groupFragment = fragment || document.createDocumentFragment();
+ var getGroupChoices = function getGroupChoices(group) {
+ return choices.filter(function (choice) {
+ if (_this12._isSelectOneElement) {
+ return choice.groupId === group.id;
+ }
+ return choice.groupId === group.id && (_this12.config.renderSelectedChoices === 'always' || !choice.selected);
+ });
+ };
+
+ // If sorting is enabled, filter groups
+ if (this.config.shouldSort) {
+ groups.sort(this.config.sortFn);
+ }
+
+ groups.forEach(function (group) {
+ var groupChoices = getGroupChoices(group);
+ if (groupChoices.length >= 1) {
+ var dropdownGroup = _this12._getTemplate('choiceGroup', group);
+ groupFragment.appendChild(dropdownGroup);
+ _this12._createChoicesFragment(groupChoices, groupFragment, true);
+ }
+ });
+
+ return groupFragment;
+ }
+
+ /**
+ * Render choices into a DOM fragment and append to choice list
+ * @param {Array} choices Choices to add to list
+ * @param {DocumentFragment} fragment Fragment to add choices to (optional)
+ * @return {DocumentFragment} Populated choices fragment
+ * @private
+ */
+
+ }, {
+ key: '_createChoicesFragment',
+ value: function _createChoicesFragment(choices, fragment) {
+ var _this13 = this;
+
+ var withinGroup = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+ // Create a fragment to store our list items (so we don't have to update the DOM for each item)
+ var choicesFragment = fragment || document.createDocumentFragment();
+ var _config = this.config,
+ renderSelectedChoices = _config.renderSelectedChoices,
+ searchResultLimit = _config.searchResultLimit,
+ renderChoiceLimit = _config.renderChoiceLimit;
+
+ var filter = this._isSearching ? _utils.sortByScore : this.config.sortFn;
+ var appendChoice = function appendChoice(choice) {
+ var shouldRender = renderSelectedChoices === 'auto' ? _this13._isSelectOneElement || !choice.selected : true;
+ if (shouldRender) {
+ var dropdownItem = _this13._getTemplate('choice', choice, _this13.config.itemSelectText);
+ choicesFragment.appendChild(dropdownItem);
+ }
+ };
+
+ var rendererableChoices = choices;
+
+ if (renderSelectedChoices === 'auto' && !this._isSelectOneElement) {
+ rendererableChoices = choices.filter(function (choice) {
+ return !choice.selected;
+ });
+ }
+
+ // Split array into placeholders and "normal" choices
+
+ var _rendererableChoices$ = rendererableChoices.reduce(function (acc, choice) {
+ if (choice.placeholder) {
+ acc.placeholderChoices.push(choice);
+ } else {
+ acc.normalChoices.push(choice);
+ }
+ return acc;
+ }, { placeholderChoices: [], normalChoices: [] }),
+ placeholderChoices = _rendererableChoices$.placeholderChoices,
+ normalChoices = _rendererableChoices$.normalChoices;
+
+ // If sorting is enabled or the user is searching, filter choices
+
+
+ if (this.config.shouldSort || this._isSearching) {
+ normalChoices.sort(filter);
+ }
+
+ var choiceLimit = rendererableChoices.length;
+
+ // Prepend placeholeder
+ var sortedChoices = [].concat(_toConsumableArray(placeholderChoices), _toConsumableArray(normalChoices));
+
+ if (this._isSearching) {
+ choiceLimit = searchResultLimit;
+ } else if (renderChoiceLimit > 0 && !withinGroup) {
+ choiceLimit = renderChoiceLimit;
+ }
+
+ // Add each choice to dropdown within range
+ for (var i = 0; i < choiceLimit; i += 1) {
+ if (sortedChoices[i]) {
+ appendChoice(sortedChoices[i]);
+ }
+ }
+
+ return choicesFragment;
+ }
+
+ /**
+ * Render items into a DOM fragment and append to items list
+ * @param {Array} items Items to add to list
+ * @param {DocumentFragment} [fragment] Fragment to add items to (optional)
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_createItemsFragment',
+ value: function _createItemsFragment(items) {
+ var _this14 = this;
+
+ var fragment = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+
+ // Create fragment to add elements to
+ var _config2 = this.config,
+ shouldSortItems = _config2.shouldSortItems,
+ sortFn = _config2.sortFn,
+ removeItemButton = _config2.removeItemButton;
+
+ var itemListFragment = fragment || document.createDocumentFragment();
+
+ // If sorting is enabled, filter items
+ if (shouldSortItems && !this._isSelectOneElement) {
+ items.sort(sortFn);
+ }
+
+ if (this._isTextElement) {
+ // Update the value of the hidden input
+ this.passedElement.value = items;
+ } else {
+ // Update the options of the hidden input
+ this.passedElement.options = items;
+ }
+
+ var addItemToFragment = function addItemToFragment(item) {
+ // Create new list element
+ var listItem = _this14._getTemplate('item', item, removeItemButton);
+ // Append it to list
+ itemListFragment.appendChild(listItem);
+ };
+
+ // Add each list item to list
+ items.forEach(function (item) {
+ return addItemToFragment(item);
+ });
+
+ return itemListFragment;
+ }
+
+ /**
+ * Call change callback
+ * @param {String} value - last added/deleted/selected value
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_triggerChange',
+ value: function _triggerChange(value) {
+ if (value === undefined || value === null) {
+ return;
+ }
+
+ this.passedElement.triggerEvent(_constants.EVENTS.change, {
+ value: value
+ });
+ }
+
+ /**
+ * Select placeholder choice
+ */
+
+ }, {
+ key: '_selectPlaceholderChoice',
+ value: function _selectPlaceholderChoice() {
+ var placeholderChoice = this._store.placeholderChoice;
+
+ if (placeholderChoice) {
+ this._addItem(placeholderChoice.value, placeholderChoice.label, placeholderChoice.id, placeholderChoice.groupId, null, placeholderChoice.placeholder);
+ this._triggerChange(placeholderChoice.value);
+ }
+ }
+
+ /**
+ * Process enter/click of an item button
+ * @param {Array} activeItems The currently active items
+ * @param {Element} element Button being interacted with
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_handleButtonAction',
+ value: function _handleButtonAction(activeItems, element) {
+ if (!activeItems || !element || !this.config.removeItems || !this.config.removeItemButton) {
+ return;
+ }
+
+ var itemId = element.parentNode.getAttribute('data-id');
+ var itemToRemove = activeItems.find(function (item) {
+ return item.id === parseInt(itemId, 10);
+ });
+
+ // Remove item associated with button
+ this._removeItem(itemToRemove);
+ this._triggerChange(itemToRemove.value);
+
+ if (this._isSelectOneElement) {
+ this._selectPlaceholderChoice();
+ }
+ }
+
+ /**
+ * Process click of an item
+ * @param {Array} activeItems The currently active items
+ * @param {Element} element Item being interacted with
+ * @param {Boolean} hasShiftKey Whether the user has the shift key active
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_handleItemAction',
+ value: function _handleItemAction(activeItems, element) {
+ var _this15 = this;
+
+ var hasShiftKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+ if (!activeItems || !element || !this.config.removeItems || this._isSelectOneElement) {
+ return;
+ }
+
+ var passedId = element.getAttribute('data-id');
+
+ // We only want to select one item with a click
+ // so we deselect any items that aren't the target
+ // unless shift is being pressed
+ activeItems.forEach(function (item) {
+ if (item.id === parseInt(passedId, 10) && !item.highlighted) {
+ _this15.highlightItem(item);
+ } else if (!hasShiftKey && item.highlighted) {
+ _this15.unhighlightItem(item);
+ }
+ });
+
+ // Focus input as without focus, a user cannot do anything with a
+ // highlighted item
+ this.input.focus();
+ }
+
+ /**
+ * Process click of a choice
+ * @param {Array} activeItems The currently active items
+ * @param {Element} element Choice being interacted with
+ * @return
+ */
+
+ }, {
+ key: '_handleChoiceAction',
+ value: function _handleChoiceAction(activeItems, element) {
+ if (!activeItems || !element) {
+ return;
+ }
+
+ // If we are clicking on an option
+ var id = element.getAttribute('data-id');
+ var choice = this._store.getChoiceById(id);
+ var passedKeyCode = activeItems[0] && activeItems[0].keyCode ? activeItems[0].keyCode : null;
+ var hasActiveDropdown = this.dropdown.isActive;
+
+ // Update choice keyCode
+ choice.keyCode = passedKeyCode;
+
+ this.passedElement.triggerEvent(_constants.EVENTS.choice, {
+ choice: choice
+ });
+
+ if (choice && !choice.selected && !choice.disabled) {
+ var canAddItem = this._canAddItem(activeItems, choice.value);
+
+ if (canAddItem.response) {
+ this._addItem(choice.value, choice.label, choice.id, choice.groupId, choice.customProperties, choice.placeholder, choice.keyCode);
+ this._triggerChange(choice.value);
+ }
+ }
+
+ this.clearInput();
+
+ // We wont to close the dropdown if we are dealing with a single select box
+ if (hasActiveDropdown && this._isSelectOneElement) {
+ this.hideDropdown();
+ this.containerOuter.focus();
+ }
+ }
+
+ /**
+ * Process back space event
+ * @param {Array} activeItems items
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_handleBackspace',
+ value: function _handleBackspace(activeItems) {
+ if (!this.config.removeItems || !activeItems) {
+ return;
+ }
+
+ var lastItem = activeItems[activeItems.length - 1];
+ var hasHighlightedItems = activeItems.some(function (item) {
+ return item.highlighted;
+ });
+
+ // If editing the last item is allowed and there are not other selected items,
+ // we can edit the item value. Otherwise if we can remove items, remove all selected items
+ if (this.config.editItems && !hasHighlightedItems && lastItem) {
+ this.input.value = lastItem.value;
+ this.input.setWidth();
+ this._removeItem(lastItem);
+ this._triggerChange(lastItem.value);
+ } else {
+ if (!hasHighlightedItems) {
+ // Highlight last item if none already highlighted
+ this.highlightItem(lastItem, false);
+ }
+ this.removeHighlightedItems(true);
+ }
+ }
+
+ /**
+ * Apply or remove a loading state to the component.
+ * @param {Boolean} isLoading default value set to 'true'.
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_handleLoadingState',
+ value: function _handleLoadingState() {
+ var isLoading = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+
+ var placeholderItem = this.itemList.getChild('.' + this.config.classNames.placeholder);
+ if (isLoading) {
+ this.containerOuter.addLoadingState();
+ if (this._isSelectOneElement) {
+ if (!placeholderItem) {
+ placeholderItem = this._getTemplate('placeholder', this.config.loadingText);
+ this.itemList.append(placeholderItem);
+ } else {
+ placeholderItem.innerHTML = this.config.loadingText;
+ }
+ } else {
+ this.input.placeholder = this.config.loadingText;
+ }
+ } else {
+ this.containerOuter.removeLoadingState();
+
+ if (this._isSelectOneElement) {
+ placeholderItem.innerHTML = this._placeholderValue || '';
+ } else {
+ this.input.placeholder = this._placeholderValue || '';
+ }
+ }
+ }
+
+ /**
+ * Validates whether an item can be added by a user
+ * @param {Array} activeItems The currently active items
+ * @param {String} value Value of item to add
+ * @return {Object} Response: Whether user can add item
+ * Notice: Notice show in dropdown
+ */
+
+ }, {
+ key: '_canAddItem',
+ value: function _canAddItem(activeItems, value) {
+ var canAddItem = true;
+ var notice = (0, _utils.isType)('Function', this.config.addItemText) ? this.config.addItemText(value) : this.config.addItemText;
+
+ if (this._isSelectMultipleElement || this._isTextElement) {
+ if (this.config.maxItemCount > 0 && this.config.maxItemCount <= activeItems.length) {
+ // If there is a max entry limit and we have reached that limit
+ // don't update
+ canAddItem = false;
+ notice = (0, _utils.isType)('Function', this.config.maxItemText) ? this.config.maxItemText(this.config.maxItemCount) : this.config.maxItemText;
+ }
+ }
+
+ if (this.config.regexFilter && this._isTextElement && this.config.addItems && canAddItem) {
+ // If a user has supplied a regular expression filter
+ // determine whether we can update based on whether
+ // our regular expression passes
+ canAddItem = (0, _utils.regexFilter)(value, this.config.regexFilter);
+ }
+
+ // If no duplicates are allowed, and the value already exists
+ // in the array
+ var isUnique = !activeItems.some(function (item) {
+ if ((0, _utils.isType)('String', value)) {
+ return item.value === value.trim();
+ }
+
+ return item.value === value;
+ });
+
+ if (!isUnique && !this.config.duplicateItems && !this._isSelectOneElement && canAddItem) {
+ canAddItem = false;
+ notice = (0, _utils.isType)('Function', this.config.uniqueItemText) ? this.config.uniqueItemText(value) : this.config.uniqueItemText;
+ }
+
+ return {
+ response: canAddItem,
+ notice: notice
+ };
+ }
+
+ /**
+ * Retrieve the callback used to populate component's choices in an async way.
+ * @returns {Function} The callback as a function.
+ * @private
+ */
+
+ }, {
+ key: '_ajaxCallback',
+ value: function _ajaxCallback() {
+ var _this16 = this;
+
+ return function (results, value, label) {
+ if (!results || !value) {
+ return;
+ }
+
+ var parsedResults = (0, _utils.isType)('Object', results) ? [results] : results;
+
+ if (parsedResults && (0, _utils.isType)('Array', parsedResults) && parsedResults.length) {
+ // Remove loading states/text
+ _this16._handleLoadingState(false);
+ // Add each result as a choice
+ parsedResults.forEach(function (result) {
+ if (result.choices) {
+ var groupId = result.id || null;
+ _this16._addGroup(result, groupId, value, label);
+ } else {
+ _this16._addChoice(result[value], result[label], result.selected, result.disabled, undefined, result.customProperties, result.placeholder);
+ }
+ });
+
+ if (_this16._isSelectOneElement) {
+ _this16._selectPlaceholderChoice();
+ }
+ } else {
+ // No results, remove loading state
+ _this16._handleLoadingState(false);
+ }
+ };
+ }
+
+ /**
+ * Filter choices based on search value
+ * @param {String} value Value to filter by
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_searchChoices',
+ value: function _searchChoices(value) {
+ var newValue = (0, _utils.isType)('String', value) ? value.trim() : value;
+ var currentValue = (0, _utils.isType)('String', this._currentValue) ? this._currentValue.trim() : this._currentValue;
+
+ if (newValue.length < 1 && newValue === currentValue + ' ') {
+ return 0;
+ }
+
+ // If new value matches the desired length and is not the same as the current value with a space
+ var haystack = this._store.searchableChoices;
+ var needle = newValue;
+ var keys = (0, _utils.isType)('Array', this.config.searchFields) ? this.config.searchFields : [this.config.searchFields];
+ var options = Object.assign(this.config.fuseOptions, { keys: keys });
+ var fuse = new _fuse2.default(haystack, options);
+ var results = fuse.search(needle);
+
+ this._currentValue = newValue;
+ this._highlightPosition = 0;
+ this._isSearching = true;
+ this._store.dispatch((0, _choices.filterChoices)(results));
+
+ return results.length;
+ }
+
+ /**
+ * Determine the action when a user is searching
+ * @param {String} value Value entered by user
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_handleSearch',
+ value: function _handleSearch(value) {
+ if (!value || !this.input.isFocussed) {
+ return;
+ }
+
+ var choices = this._store.choices;
+ var _config3 = this.config,
+ searchFloor = _config3.searchFloor,
+ searchChoices = _config3.searchChoices;
+
+ var hasUnactiveChoices = choices.some(function (option) {
+ return !option.active;
+ });
+
+ // Check that we have a value to search and the input was an alphanumeric character
+ if (value && value.length >= searchFloor) {
+ var resultCount = searchChoices ? this._searchChoices(value) : 0;
+ // Trigger search event
+ this.passedElement.triggerEvent(_constants.EVENTS.search, {
+ value: value,
+ resultCount: resultCount
+ });
+ } else if (hasUnactiveChoices) {
+ // Otherwise reset choices to active
+ this._isSearching = false;
+ this._store.dispatch((0, _choices.activateChoices)(true));
+ }
+ }
+
+ /**
+ * Trigger event listeners
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_addEventListeners',
+ value: function _addEventListeners() {
+ document.addEventListener('keyup', this._onKeyUp);
+ document.addEventListener('keydown', this._onKeyDown);
+ document.addEventListener('click', this._onClick);
+ document.addEventListener('touchmove', this._onTouchMove);
+ document.addEventListener('touchend', this._onTouchEnd);
+ document.addEventListener('mousedown', this._onMouseDown);
+ document.addEventListener('mouseover', this._onMouseOver);
+
+ if (this._isSelectOneElement) {
+ this.containerOuter.element.addEventListener('focus', this._onFocus);
+ this.containerOuter.element.addEventListener('blur', this._onBlur);
+ }
+
+ this.input.element.addEventListener('focus', this._onFocus);
+ this.input.element.addEventListener('blur', this._onBlur);
+
+ this.input.addEventListeners();
+ }
+
+ /**
+ * Remove event listeners
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_removeEventListeners',
+ value: function _removeEventListeners() {
+ document.removeEventListener('keyup', this._onKeyUp);
+ document.removeEventListener('keydown', this._onKeyDown);
+ document.removeEventListener('click', this._onClick);
+ document.removeEventListener('touchmove', this._onTouchMove);
+ document.removeEventListener('touchend', this._onTouchEnd);
+ document.removeEventListener('mousedown', this._onMouseDown);
+ document.removeEventListener('mouseover', this._onMouseOver);
+
+ if (this._isSelectOneElement) {
+ this.containerOuter.element.removeEventListener('focus', this._onFocus);
+ this.containerOuter.element.removeEventListener('blur', this._onBlur);
+ }
+
+ this.input.element.removeEventListener('focus', this._onFocus);
+ this.input.element.removeEventListener('blur', this._onBlur);
+ this.input.removeEventListeners();
+ }
+
+ /**
+ * Key down event
+ * @param {Object} e Event
+ * @return
+ */
+
+ }, {
+ key: '_onKeyDown',
+ value: function _onKeyDown(e) {
+ var _this17 = this,
+ _keyDownActions;
+
+ if (e.target !== this.input.element && !this.containerOuter.element.contains(e.target)) {
+ return;
+ }
+
+ var target = e.target;
+ var activeItems = this._store.activeItems;
+ var hasFocusedInput = this.input.isFocussed;
+ var hasActiveDropdown = this.dropdown.isActive;
+ var hasItems = this.itemList.hasChildren;
+ var keyString = String.fromCharCode(e.keyCode);
+ var backKey = _constants.KEY_CODES.BACK_KEY;
+ var deleteKey = _constants.KEY_CODES.DELETE_KEY;
+ var enterKey = _constants.KEY_CODES.ENTER_KEY;
+ var aKey = _constants.KEY_CODES.A_KEY;
+ var escapeKey = _constants.KEY_CODES.ESC_KEY;
+ var upKey = _constants.KEY_CODES.UP_KEY;
+ var downKey = _constants.KEY_CODES.DOWN_KEY;
+ var pageUpKey = _constants.KEY_CODES.PAGE_UP_KEY;
+ var pageDownKey = _constants.KEY_CODES.PAGE_DOWN_KEY;
+ var ctrlDownKey = e.ctrlKey || e.metaKey;
+
+ // If a user is typing and the dropdown is not active
+ if (!this._isTextElement && /[a-zA-Z0-9-_ ]/.test(keyString)) {
+ this.showDropdown(true);
+ }
+
+ this.config.searchEnabled = this.config.searchEnabled;
+
+ var onAKey = function onAKey() {
+ // If CTRL + A or CMD + A have been pressed and there are items to select
+ if (ctrlDownKey && hasItems) {
+ _this17.config.searchEnabled = false;
+ if (_this17.config.removeItems && !_this17.input.value && _this17.input.element === document.activeElement) {
+ // Highlight items
+ _this17.highlightAll();
+ }
+ }
+ };
+
+ var onEnterKey = function onEnterKey() {
+ // If enter key is pressed and the input has a value
+ if (_this17._isTextElement && target.value) {
+ var value = _this17.input.value;
+ var canAddItem = _this17._canAddItem(activeItems, value);
+
+ // All is good, add
+ if (canAddItem.response) {
+ _this17.hideDropdown();
+ _this17._addItem(value);
+ _this17._triggerChange(value);
+ _this17.clearInput();
+ }
+ }
+
+ if (target.hasAttribute('data-button')) {
+ _this17._handleButtonAction(activeItems, target);
+ e.preventDefault();
+ }
+
+ if (hasActiveDropdown) {
+ e.preventDefault();
+ var highlighted = _this17.dropdown.getChild('.' + _this17.config.classNames.highlightedState);
+
+ // If we have a highlighted choice
+ if (highlighted) {
+ // add enter keyCode value
+ if (activeItems[0]) {
+ activeItems[0].keyCode = enterKey;
+ }
+ _this17._handleChoiceAction(activeItems, highlighted);
+ }
+ } else if (_this17._isSelectOneElement) {
+ // Open single select dropdown if it's not active
+ _this17.showDropdown(true);
+ e.preventDefault();
+ }
+ };
+
+ var onEscapeKey = function onEscapeKey() {
+ if (hasActiveDropdown) {
+ _this17.hideDropdown();
+ _this17.containerOuter.focus();
+ }
+ };
+
+ var onDirectionKey = function onDirectionKey() {
+ // If up or down key is pressed, traverse through options
+ if (hasActiveDropdown || _this17._isSelectOneElement) {
+ // Show dropdown if focus
+ _this17.showDropdown(true);
+
+ _this17.config.searchEnabled = false;
+
+ var directionInt = e.keyCode === downKey || e.keyCode === pageDownKey ? 1 : -1;
+ var skipKey = e.metaKey || e.keyCode === pageDownKey || e.keyCode === pageUpKey;
+ var selectableChoiceIdentifier = '[data-choice-selectable]';
+
+ var nextEl = void 0;
+ if (skipKey) {
+ if (directionInt > 0) {
+ nextEl = Array.from(_this17.dropdown.element.querySelectorAll(selectableChoiceIdentifier)).pop();
+ } else {
+ nextEl = _this17.dropdown.element.querySelector(selectableChoiceIdentifier);
+ }
+ } else {
+ var currentEl = _this17.dropdown.element.querySelector('.' + _this17.config.classNames.highlightedState);
+ if (currentEl) {
+ nextEl = (0, _utils.getAdjacentEl)(currentEl, selectableChoiceIdentifier, directionInt);
+ } else {
+ nextEl = _this17.dropdown.element.querySelector(selectableChoiceIdentifier);
+ }
+ }
+
+ if (nextEl) {
+ // We prevent default to stop the cursor moving
+ // when pressing the arrow
+ if (!(0, _utils.isScrolledIntoView)(nextEl, _this17.choiceList.element, directionInt)) {
+ _this17._scrollToChoice(nextEl, directionInt);
+ }
+ _this17._highlightChoice(nextEl);
+ }
+
+ // Prevent default to maintain cursor position whilst
+ // traversing dropdown options
+ e.preventDefault();
+ }
+ };
+
+ var onDeleteKey = function onDeleteKey() {
+ // If backspace or delete key is pressed and the input has no value
+ if (hasFocusedInput && !e.target.value && !_this17._isSelectOneElement) {
+ _this17._handleBackspace(activeItems);
+ e.preventDefault();
+ }
+ };
+
+ // Map keys to key actions
+ var keyDownActions = (_keyDownActions = {}, _defineProperty(_keyDownActions, aKey, onAKey), _defineProperty(_keyDownActions, enterKey, onEnterKey), _defineProperty(_keyDownActions, escapeKey, onEscapeKey), _defineProperty(_keyDownActions, upKey, onDirectionKey), _defineProperty(_keyDownActions, pageUpKey, onDirectionKey), _defineProperty(_keyDownActions, downKey, onDirectionKey), _defineProperty(_keyDownActions, pageDownKey, onDirectionKey), _defineProperty(_keyDownActions, deleteKey, onDeleteKey), _defineProperty(_keyDownActions, backKey, onDeleteKey), _keyDownActions);
+
+ // If keycode has a function, run it
+ if (keyDownActions[e.keyCode]) {
+ keyDownActions[e.keyCode]();
+ }
+ }
+
+ /**
+ * Key up event
+ * @param {Object} e Event
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_onKeyUp',
+ value: function _onKeyUp(e) {
+ if (e.target !== this.input.element) {
+ return;
+ }
+
+ var value = this.input.value;
+ var activeItems = this._store.activeItems;
+ var canAddItem = this._canAddItem(activeItems, value);
+
+ // We are typing into a text input and have a value, we want to show a dropdown
+ // notice. Otherwise hide the dropdown
+ if (this._isTextElement) {
+ if (value) {
+ if (canAddItem.notice) {
+ var dropdownItem = this._getTemplate('notice', canAddItem.notice);
+ this.dropdown.element.innerHTML = dropdownItem.outerHTML;
+ }
+
+ if (canAddItem.response === true) {
+ this.showDropdown();
+ } else if (!canAddItem.notice) {
+ this.hideDropdown();
+ }
+ } else {
+ this.hideDropdown();
+ }
+ } else {
+ var backKey = _constants.KEY_CODES.BACK_KEY;
+ var deleteKey = _constants.KEY_CODES.DELETE_KEY;
+
+ // If user has removed value...
+ if ((e.keyCode === backKey || e.keyCode === deleteKey) && !e.target.value) {
+ // ...and it is a multiple select input, activate choices (if searching)
+ if (!this._isTextElement && this._isSearching) {
+ this._isSearching = false;
+ this._store.dispatch((0, _choices.activateChoices)(true));
+ }
+ } else if (this.config.searchEnabled && canAddItem.response) {
+ this._handleSearch(this.input.value);
+ }
+ }
+ // Re-establish canSearch value from changes in _onKeyDown
+ this.config.searchEnabled = this.config.searchEnabled;
+ }
+
+ /**
+ * Touch move event
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_onTouchMove',
+ value: function _onTouchMove() {
+ if (this._wasTap === true) {
+ this._wasTap = false;
+ }
+ }
+
+ /**
+ * Touch end event
+ * @param {Object} e Event
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_onTouchEnd',
+ value: function _onTouchEnd(e) {
+ var target = e.target || e.touches[0].target;
+
+ // If a user tapped within our container...
+ if (this._wasTap === true && this.containerOuter.element.contains(target)) {
+ // ...and we aren't dealing with a single select box, show dropdown/focus input
+ if ((target === this.containerOuter.element || target === this.containerInner.element) && !this._isSelectOneElement) {
+ if (this._isTextElement) {
+ // If text element, we only want to focus the input
+ this.input.focus();
+ } else {
+ // If a select box, we want to show the dropdown
+ this.showDropdown(true);
+ }
+ }
+ // Prevents focus event firing
+ e.stopPropagation();
+ }
+
+ this._wasTap = true;
+ }
+
+ /**
+ * Mouse down event
+ * @param {Object} e Event
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_onMouseDown',
+ value: function _onMouseDown(e) {
+ var target = e.target;
+
+ // If we have our mouse down on the scrollbar and are on IE11...
+ if (target === this.choiceList && (0, _utils.isIE11)()) {
+ this._isScrollingOnIe = true;
+ }
+
+ if (this.containerOuter.element.contains(target) && target !== this.input.element) {
+ var activeItems = this._store.activeItems;
+ var hasShiftKey = e.shiftKey;
+
+ var buttonTarget = (0, _utils.findAncestorByAttrName)(target, 'data-button');
+ var itemTarget = (0, _utils.findAncestorByAttrName)(target, 'data-item');
+ var choiceTarget = (0, _utils.findAncestorByAttrName)(target, 'data-choice');
+
+ if (buttonTarget) {
+ this._handleButtonAction(activeItems, buttonTarget);
+ } else if (itemTarget) {
+ this._handleItemAction(activeItems, itemTarget, hasShiftKey);
+ } else if (choiceTarget) {
+ this._handleChoiceAction(activeItems, choiceTarget);
+ }
+
+ e.preventDefault();
+ }
+ }
+
+ /**
+ * Mouse over (hover) event
+ * @param {Object} e Event
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_onMouseOver',
+ value: function _onMouseOver(e) {
+ // If the dropdown is either the target or one of its children is the target
+ var targetWithinDropdown = e.target === this.dropdown || this.dropdown.element.contains(e.target);
+ var shouldHighlightChoice = targetWithinDropdown && e.target.hasAttribute('data-choice');
+
+ if (shouldHighlightChoice) {
+ this._highlightChoice(e.target);
+ }
+ }
+
+ /**
+ * Click event
+ * @param {Object} e Event
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_onClick',
+ value: function _onClick(e) {
+ var target = e.target;
+ var hasActiveDropdown = this.dropdown.isActive;
+ var activeItems = this._store.activeItems;
+
+ // If target is something that concerns us
+ if (this.containerOuter.element.contains(target)) {
+ if (!hasActiveDropdown) {
+ if (this._isTextElement) {
+ if (document.activeElement !== this.input.element) {
+ this.input.focus();
+ }
+ } else if (this.config.searchEnabled) {
+ this.showDropdown(true);
+ } else {
+ this.showDropdown();
+ // code smell
+ this.containerOuter.focus();
+ }
+ } else if (this._isSelectOneElement && target !== this.input.element && !this.dropdown.element.contains(target)) {
+ this.hideDropdown(true);
+ }
+ } else {
+ var hasHighlightedItems = activeItems.some(function (item) {
+ return item.highlighted;
+ });
+
+ // De-select any highlighted items
+ if (hasHighlightedItems) {
+ this.unhighlightAll();
+ }
+
+ // Remove focus state
+ this.containerOuter.removeFocusState();
+
+ // Close all other dropdowns
+ this.hideDropdown();
+ }
+ }
+
+ /**
+ * Focus event
+ * @param {Object} e Event
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_onFocus',
+ value: function _onFocus(e) {
+ var _this18 = this;
+
+ var target = e.target;
+ if (!this.containerOuter.element.contains(target)) {
+ return;
+ }
+
+ var focusActions = {
+ text: function text() {
+ if (target === _this18.input.element) {
+ _this18.containerOuter.addFocusState();
+ }
+ },
+ 'select-one': function selectOne() {
+ _this18.containerOuter.addFocusState();
+ if (target === _this18.input.element) {
+ // Show dropdown if it isn't already showing
+ _this18.showDropdown();
+ }
+ },
+ 'select-multiple': function selectMultiple() {
+ if (target === _this18.input.element) {
+ // If element is a select box, the focused element is the container and the dropdown
+ // isn't already open, focus and show dropdown
+ _this18.containerOuter.addFocusState();
+ _this18.showDropdown(true);
+ }
+ }
+ };
+
+ focusActions[this.passedElement.element.type]();
+ }
+
+ /**
+ * Blur event
+ * @param {Object} e Event
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_onBlur',
+ value: function _onBlur(e) {
+ var _this19 = this;
+
+ var target = e.target;
+ // If target is something that concerns us
+ if (this.containerOuter.element.contains(target) && !this._isScrollingOnIe) {
+ var activeItems = this._store.activeItems;
+ var hasHighlightedItems = activeItems.some(function (item) {
+ return item.highlighted;
+ });
+ var blurActions = {
+ text: function text() {
+ if (target === _this19.input.element) {
+ // Remove the focus state
+ _this19.containerOuter.removeFocusState();
+ // De-select any highlighted items
+ if (hasHighlightedItems) {
+ _this19.unhighlightAll();
+ }
+ _this19.hideDropdown();
+ }
+ },
+ 'select-one': function selectOne() {
+ _this19.containerOuter.removeFocusState();
+ if (target === _this19.input.element || target === _this19.containerOuter.element && !_this19.config.searchEnabled) {
+ _this19.hideDropdown();
+ }
+ },
+ 'select-multiple': function selectMultiple() {
+ if (target === _this19.input.element) {
+ // Remove the focus state
+ _this19.containerOuter.removeFocusState();
+ _this19.hideDropdown();
+ // De-select any highlighted items
+ if (hasHighlightedItems) {
+ _this19.unhighlightAll();
+ }
+ }
+ }
+ };
+
+ blurActions[this.passedElement.element.type]();
+ } else {
+ // On IE11, clicking the scollbar blurs our input and thus
+ // closes the dropdown. To stop this, we refocus our input
+ // if we know we are on IE *and* are scrolling.
+ this._isScrollingOnIe = false;
+ this.input.element.focus();
+ }
+ }
+
+ /**
+ * Scroll to an option element
+ * @param {HTMLElement} choice Option to scroll to
+ * @param {Number} direction Whether option is above or below
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_scrollToChoice',
+ value: function _scrollToChoice(choice, direction) {
+ var _this20 = this;
+
+ if (!choice) {
+ return;
+ }
+
+ var dropdownHeight = this.choiceList.element.offsetHeight;
+ var choiceHeight = choice.offsetHeight;
+ // Distance from bottom of element to top of parent
+ var choicePos = choice.offsetTop + choiceHeight;
+ // Scroll position of dropdown
+ var containerScrollPos = this.choiceList.element.scrollTop + dropdownHeight;
+ // Difference between the choice and scroll position
+ var endPoint = direction > 0 ? this.choiceList.element.scrollTop + choicePos - containerScrollPos : choice.offsetTop;
+
+ var animateScroll = function animateScroll() {
+ var strength = _constants.SCROLLING_SPEED;
+ var choiceListScrollTop = _this20.choiceList.element.scrollTop;
+ var continueAnimation = false;
+ var easing = void 0;
+ var distance = void 0;
+
+ if (direction > 0) {
+ easing = (endPoint - choiceListScrollTop) / strength;
+ distance = easing > 1 ? easing : 1;
+
+ _this20.choiceList.scrollTo(choiceListScrollTop + distance);
+ if (choiceListScrollTop < endPoint) {
+ continueAnimation = true;
+ }
+ } else {
+ easing = (choiceListScrollTop - endPoint) / strength;
+ distance = easing > 1 ? easing : 1;
+
+ _this20.choiceList.scrollTo(choiceListScrollTop - distance);
+ if (choiceListScrollTop > endPoint) {
+ continueAnimation = true;
+ }
+ }
+
+ if (continueAnimation) {
+ requestAnimationFrame(function (time) {
+ animateScroll(time, endPoint, direction);
+ });
+ }
+ };
+
+ requestAnimationFrame(function (time) {
+ animateScroll(time, endPoint, direction);
+ });
+ }
+
+ /**
+ * Highlight choice
+ * @param {HTMLElement} [el] Element to highlight
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_highlightChoice',
+ value: function _highlightChoice() {
+ var _this21 = this;
+
+ var el = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+
+ // Highlight first element in dropdown
+ var choices = Array.from(this.dropdown.element.querySelectorAll('[data-choice-selectable]'));
+
+ if (!choices.length) {
+ return;
+ }
+
+ var passedEl = el;
+ var highlightedChoices = Array.from(this.dropdown.element.querySelectorAll('.' + this.config.classNames.highlightedState));
+ var hasActiveDropdown = this.dropdown.isActive;
+
+ // Remove any highlighted choices
+ highlightedChoices.forEach(function (choice) {
+ choice.classList.remove(_this21.config.classNames.highlightedState);
+ choice.setAttribute('aria-selected', 'false');
+ });
+
+ if (passedEl) {
+ this._highlightPosition = choices.indexOf(passedEl);
+ } else {
+ // Highlight choice based on last known highlight location
+ if (choices.length > this._highlightPosition) {
+ // If we have an option to highlight
+ passedEl = choices[this._highlightPosition];
+ } else {
+ // Otherwise highlight the option before
+ passedEl = choices[choices.length - 1];
+ }
+
+ if (!passedEl) {
+ passedEl = choices[0];
+ }
+ }
+
+ // Highlight given option, and set accessiblity attributes
+ passedEl.classList.add(this.config.classNames.highlightedState);
+ passedEl.setAttribute('aria-selected', 'true');
+
+ if (hasActiveDropdown) {
+ // IE11 ignores aria-label and blocks virtual keyboard
+ // if aria-activedescendant is set without a dropdown
+ this.input.setActiveDescendant(passedEl.id);
+ this.containerOuter.setActiveDescendant(passedEl.id);
+ }
+ }
+
+ /**
+ * Add item to store with correct value
+ * @param {String} value Value to add to store
+ * @param {String} [label] Label to add to store
+ * @param {Number} [choiceId=-1] ID of the associated choice that was selected
+ * @param {Number} [groupId=-1] ID of group choice is within. Negative number indicates no group
+ * @param {Object} [customProperties] Object containing user defined properties
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: '_addItem',
+ value: function _addItem(value) {
+ var label = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+ var choiceId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+ var groupId = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
+ var customProperties = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
+ var placeholder = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
+ var keyCode = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : null;
+
+ var passedValue = (0, _utils.isType)('String', value) ? value.trim() : value;
+
+ var passedKeyCode = keyCode;
+ var passedCustomProperties = customProperties;
+ var items = this._store.items;
+ var passedLabel = label || passedValue;
+ var passedOptionId = parseInt(choiceId, 10) || -1;
+ var group = groupId >= 0 ? this._store.getGroupById(groupId) : null;
+ var id = items ? items.length + 1 : 1;
+
+ // If a prepended value has been passed, prepend it
+ if (this.config.prependValue) {
+ passedValue = this.config.prependValue + passedValue.toString();
+ }
+
+ // If an appended value has been passed, append it
+ if (this.config.appendValue) {
+ passedValue += this.config.appendValue.toString();
+ }
+
+ this._store.dispatch((0, _items.addItem)(passedValue, passedLabel, id, passedOptionId, groupId, customProperties, placeholder, passedKeyCode));
+
+ if (this._isSelectOneElement) {
+ this.removeActiveItems(id);
+ }
+
+ // Trigger change event
+ if (group && group.value) {
+ this.passedElement.triggerEvent(_constants.EVENTS.addItem, {
+ id: id,
+ value: passedValue,
+ label: passedLabel,
+ customProperties: passedCustomProperties,
+ groupValue: group.value,
+ keyCode: passedKeyCode
+ });
+ } else {
+ this.passedElement.triggerEvent(_constants.EVENTS.addItem, {
+ id: id,
+ value: passedValue,
+ label: passedLabel,
+ customProperties: passedCustomProperties,
+ keyCode: passedKeyCode
+ });
+ }
+
+ return this;
+ }
+
+ /**
+ * Remove item from store
+ * @param {Object} item Item to remove
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: '_removeItem',
+ value: function _removeItem(item) {
+ if (!item || !(0, _utils.isType)('Object', item)) {
+ return this;
+ }
+
+ var id = item.id,
+ value = item.value,
+ label = item.label,
+ choiceId = item.choiceId,
+ groupId = item.groupId;
+
+ var group = groupId >= 0 ? this._store.getGroupById(groupId) : null;
+
+ this._store.dispatch((0, _items.removeItem)(id, choiceId));
+
+ if (group && group.value) {
+ this.passedElement.triggerEvent(_constants.EVENTS.removeItem, {
+ id: id,
+ value: value,
+ label: label,
+ groupValue: group.value
+ });
+ } else {
+ this.passedElement.triggerEvent(_constants.EVENTS.removeItem, {
+ id: id,
+ value: value,
+ label: label
+ });
+ }
+
+ return this;
+ }
+
+ /**
+ * Add choice to dropdown
+ * @param {String} value Value of choice
+ * @param {String} [label] Label of choice
+ * @param {Boolean} [isSelected=false] Whether choice is selected
+ * @param {Boolean} [isDisabled=false] Whether choice is disabled
+ * @param {Number} [groupId=-1] ID of group choice is within. Negative number indicates no group
+ * @param {Object} [customProperties] Object containing user defined properties
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_addChoice',
+ value: function _addChoice(value) {
+ var label = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+ var isSelected = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+ var isDisabled = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+ var groupId = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : -1;
+ var customProperties = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : null;
+ var placeholder = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : false;
+ var keyCode = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : null;
+
+ if (typeof value === 'undefined' || value === null) {
+ return;
+ }
+
+ // Generate unique id
+ var choices = this._store.choices;
+ var choiceLabel = label || value;
+ var choiceId = choices ? choices.length + 1 : 1;
+ var choiceElementId = this._baseId + '-' + this._idNames.itemChoice + '-' + choiceId;
+
+ this._store.dispatch((0, _choices.addChoice)(value, choiceLabel, choiceId, groupId, isDisabled, choiceElementId, customProperties, placeholder, keyCode));
+
+ if (isSelected) {
+ this._addItem(value, choiceLabel, choiceId, undefined, customProperties, placeholder, keyCode);
+ }
+ }
+
+ /**
+ * Clear all choices added to the store.
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_clearChoices',
+ value: function _clearChoices() {
+ this._store.dispatch((0, _choices.clearChoices)());
+ }
+
+ /**
+ * Add group to dropdown
+ * @param {Object} group Group to add
+ * @param {Number} id Group ID
+ * @param {String} [valueKey] name of the value property on the object
+ * @param {String} [labelKey] name of the label property on the object
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_addGroup',
+ value: function _addGroup(group, id) {
+ var _this22 = this;
+
+ var valueKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'value';
+ var labelKey = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'label';
+
+ var groupChoices = (0, _utils.isType)('Object', group) ? group.choices : Array.from(group.getElementsByTagName('OPTION'));
+ var groupId = id || Math.floor(new Date().valueOf() * Math.random());
+ var isDisabled = group.disabled ? group.disabled : false;
+
+ if (groupChoices) {
+ this._store.dispatch((0, _groups.addGroup)(group.label, groupId, true, isDisabled));
+
+ var addGroupChoices = function addGroupChoices(choice) {
+ var isOptDisabled = choice.disabled || choice.parentNode && choice.parentNode.disabled;
+ _this22._addChoice(choice[valueKey], (0, _utils.isType)('Object', choice) ? choice[labelKey] : choice.innerHTML, choice.selected, isOptDisabled, groupId, choice.customProperties, choice.placeholder);
+ };
+
+ groupChoices.forEach(addGroupChoices);
+ } else {
+ this._store.dispatch((0, _groups.addGroup)(group.label, group.id, false, group.disabled));
+ }
+ }
+
+ /**
+ * Get template from name
+ * @param {String} template Name of template to get
+ * @param {...} args Data to pass to template
+ * @return {HTMLElement} Template
+ * @private
+ */
+
+ }, {
+ key: '_getTemplate',
+ value: function _getTemplate(template) {
+ var _templates$template;
+
+ if (!template) {
+ return null;
+ }
+
+ var templates = this.config.templates;
+ var globalClasses = this.config.classNames;
+
+ for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ return (_templates$template = templates[template]).call.apply(_templates$template, [this, globalClasses].concat(args));
+ }
+
+ /**
+ * Create HTML element based on type and arguments
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_createTemplates',
+ value: function _createTemplates() {
+ var callbackOnCreateTemplates = this.config.callbackOnCreateTemplates;
+
+ var userTemplates = {};
+
+ if (callbackOnCreateTemplates && (0, _utils.isType)('Function', callbackOnCreateTemplates)) {
+ userTemplates = callbackOnCreateTemplates.call(this, _utils.strToEl);
+ }
+
+ this.config.templates = (0, _utils.extend)(_templates.TEMPLATES, userTemplates);
+ }
+
+ /**
+ * Create DOM elements using templates
+ */
+
+ }, {
+ key: '_createElements',
+ value: function _createElements() {
+ var direction = this.passedElement.element.getAttribute('dir') || 'ltr';
+ var containerOuter = this._getTemplate('containerOuter', direction, this._isSelectElement, this._isSelectOneElement, this.config.searchEnabled, this.passedElement.element.type);
+ var containerInner = this._getTemplate('containerInner');
+ var itemList = this._getTemplate('itemList', this._isSelectOneElement);
+ var choiceList = this._getTemplate('choiceList', this._isSelectOneElement);
+ var input = this._getTemplate('input');
+ var dropdown = this._getTemplate('dropdown');
+
+ this.containerOuter = new _components.Container({
+ element: containerOuter,
+ classNames: this.config.classNames,
+ type: this.passedElement.element.type,
+ position: this.config.position
+ });
+
+ this.containerInner = new _components.Container({
+ element: containerInner,
+ classNames: this.config.classNames,
+ type: this.passedElement.element.type,
+ position: this.config.position
+ });
+
+ this.input = new _components.Input({
+ element: input,
+ classNames: this.config.classNames,
+ type: this.passedElement.element.type
+ });
+
+ this.choiceList = new _components.List({
+ element: choiceList
+ });
+
+ this.itemList = new _components.List({
+ element: itemList
+ });
+
+ this.dropdown = new _components.Dropdown({
+ element: dropdown,
+ classNames: this.config.classNames,
+ type: this.passedElement.element.type
+ });
+ }
+
+ /**
+ * Create DOM structure around passed select element
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_createStructure',
+ value: function _createStructure() {
+ // Hide original element
+ this.passedElement.conceal();
+ // Wrap input in container preserving DOM ordering
+ this.containerInner.wrap(this.passedElement.element);
+ // Wrapper inner container with outer container
+ this.containerOuter.wrap(this.containerInner.element);
+
+ if (this._isSelectOneElement) {
+ this.input.placeholder = this.config.searchPlaceholderValue || '';
+ } else if (this._placeholderValue) {
+ this.input.placeholder = this._placeholderValue;
+ this.input.setWidth(true);
+ }
+
+ if (!this.config.addItems) {
+ this.disable();
+ }
+
+ this.containerOuter.element.appendChild(this.containerInner.element);
+ this.containerOuter.element.appendChild(this.dropdown.element);
+ this.containerInner.element.appendChild(this.itemList.element);
+
+ if (!this._isTextElement) {
+ this.dropdown.element.appendChild(this.choiceList.element);
+ }
+
+ if (!this._isSelectOneElement) {
+ this.containerInner.element.appendChild(this.input.element);
+ } else if (this.config.searchEnabled) {
+ this.dropdown.element.insertBefore(this.input.element, this.dropdown.element.firstChild);
+ }
+
+ if (this._isSelectElement) {
+ this._addPredefinedChoices();
+ } else if (this._isTextElement) {
+ this._addPredefinedItems();
+ }
+ }
+ }, {
+ key: '_addPredefinedChoices',
+ value: function _addPredefinedChoices() {
+ var _this23 = this;
+
+ var passedGroups = this.passedElement.optionGroups;
+
+ this._highlightPosition = 0;
+ this._isSearching = false;
+
+ if (passedGroups && passedGroups.length) {
+ // If we have a placeholder option
+ var placeholderChoice = this.passedElement.placeholderOption;
+ if (placeholderChoice && placeholderChoice.parentNode.tagName === 'SELECT') {
+ this._addChoice(placeholderChoice.value, placeholderChoice.innerHTML, placeholderChoice.selected, placeholderChoice.disabled, undefined, undefined,
+ /* placeholder */true);
+ }
+
+ passedGroups.forEach(function (group) {
+ _this23._addGroup(group, group.id || null);
+ });
+ } else {
+ var passedOptions = this.passedElement.options;
+ var filter = this.config.sortFn;
+ var allChoices = this._presetChoices;
+
+ // Create array of options from option elements
+ passedOptions.forEach(function (o) {
+ allChoices.push({
+ value: o.value,
+ label: o.innerHTML,
+ selected: o.selected,
+ disabled: o.disabled || o.parentNode.disabled,
+ placeholder: o.hasAttribute('placeholder')
+ });
+ });
+
+ // If sorting is enabled or the user is searching, filter choices
+ if (this.config.shouldSort) {
+ allChoices.sort(filter);
+ }
+
+ // Determine whether there is a selected choice
+ var hasSelectedChoice = allChoices.some(function (choice) {
+ return choice.selected;
+ });
+ var handleChoice = function handleChoice(choice, index) {
+ if (_this23._isSelectElement) {
+ // If the choice is actually a group
+ if (choice.choices) {
+ _this23._addGroup(choice, choice.id || null);
+ } else {
+ // If there is a selected choice already or the choice is not
+ // the first in the array, add each choice normally
+ // Otherwise pre-select the first choice in the array if it's a single select
+ var shouldPreselect = _this23._isSelectOneElement && !hasSelectedChoice && index === 0;
+ var isSelected = shouldPreselect ? true : choice.selected;
+ var isDisabled = shouldPreselect ? false : choice.disabled;
+
+ _this23._addChoice(choice.value, choice.label, isSelected, isDisabled, undefined, choice.customProperties, choice.placeholder);
+ }
+ } else {
+ _this23._addChoice(choice.value, choice.label, choice.selected, choice.disabled, undefined, choice.customProperties, choice.placeholder);
+ }
+ };
+
+ // Add each choice
+ allChoices.forEach(function (choice, index) {
+ return handleChoice(choice, index);
+ });
+ }
+ }
+ }, {
+ key: '_addPredefinedItems',
+ value: function _addPredefinedItems() {
+ var _this24 = this;
+
+ var handlePresetItem = function handlePresetItem(item) {
+ var itemType = (0, _utils.getType)(item);
+ if (itemType === 'Object') {
+ if (!item.value) {
+ return;
+ }
+ _this24._addItem(item.value, item.label, item.id, undefined, item.customProperties, item.placeholder);
+ } else if (itemType === 'String') {
+ _this24._addItem(item);
+ }
+ };
+
+ this._presetItems.forEach(function (item) {
+ return handlePresetItem(item);
+ });
+ }
+ }, {
+ key: '_setChoiceOrItem',
+ value: function _setChoiceOrItem(item) {
+ var _this25 = this;
+
+ var itemType = (0, _utils.getType)(item).toLowerCase();
+ var handleType = {
+ object: function object() {
+ if (!item.value) {
+ return;
+ }
+
+ // If we are dealing with a select input, we need to create an option first
+ // that is then selected. For text inputs we can just add items normally.
+ if (!_this25._isTextElement) {
+ _this25._addChoice(item.value, item.label, true, false, -1, item.customProperties, item.placeholder);
+ } else {
+ _this25._addItem(item.value, item.label, item.id, undefined, item.customProperties, item.placeholder);
+ }
+ },
+ string: function string() {
+ if (!_this25._isTextElement) {
+ _this25._addChoice(item, item, true, false, -1, null);
+ } else {
+ _this25._addItem(item);
+ }
+ }
+ };
+
+ handleType[itemType]();
+ }
+ }, {
+ key: '_findAndSelectChoiceByValue',
+ value: function _findAndSelectChoiceByValue(val) {
+ var _this26 = this;
+
+ var choices = this._store.choices;
+ // Check 'value' property exists and the choice isn't already selected
+ var foundChoice = choices.find(function (choice) {
+ return _this26.config.itemComparer(choice.value, val);
+ });
+
+ if (foundChoice && !foundChoice.selected) {
+ this._addItem(foundChoice.value, foundChoice.label, foundChoice.id, foundChoice.groupId, foundChoice.customProperties, foundChoice.placeholder, foundChoice.keyCode);
+ }
+ }
+ }, {
+ key: '_generateInstances',
+ value: function _generateInstances(elements, config) {
+ return elements.reduce(function (instances, element) {
+ instances.push(new Choices(element, config));
+ return instances;
+ }, [this]);
+ }
+ }, {
+ key: '_generatePlaceholderValue',
+ value: function _generatePlaceholderValue() {
+ if (!this._isSelectOneElement) {
+ return this.config.placeholder ? this.config.placeholderValue || this.passedElement.element.getAttribute('placeholder') : false;
+ }
+
+ return false;
+ }
+ }, {
+ key: '_renderChoices',
+ value: function _renderChoices() {
+ // Get active groups/choices
+ var activeGroups = this._store.activeGroups;
+ var activeChoices = this._store.activeChoices;
+
+ var choiceListFragment = document.createDocumentFragment();
+
+ // Clear choices
+ this.choiceList.clear();
+
+ // Scroll back to top of choices list
+ if (this.config.resetScrollPosition) {
+ this.choiceList.scrollTo(0);
+ }
+
+ // If we have grouped options
+ if (activeGroups.length >= 1 && !this._isSearching) {
+ // If we have a placeholder choice along with groups
+ var activePlaceholders = activeChoices.filter(function (activeChoice) {
+ return activeChoice.placeholder === true && activeChoice.groupId === -1;
+ });
+ if (activePlaceholders.length >= 1) {
+ choiceListFragment = this._createChoicesFragment(activePlaceholders, choiceListFragment);
+ }
+ choiceListFragment = this._createGroupsFragment(activeGroups, activeChoices, choiceListFragment);
+ } else if (activeChoices.length >= 1) {
+ choiceListFragment = this._createChoicesFragment(activeChoices, choiceListFragment);
+ }
+
+ // If we have choices to show
+ if (choiceListFragment.childNodes && choiceListFragment.childNodes.length > 0) {
+ var activeItems = this._store.activeItems;
+ var canAddItem = this._canAddItem(activeItems, this.input.value);
+
+ // ...and we can select them
+ if (canAddItem.response) {
+ // ...append them and highlight the first choice
+ this.choiceList.append(choiceListFragment);
+ this._highlightChoice();
+ } else {
+ // ...otherwise show a notice
+ this.choiceList.append(this._getTemplate('notice', canAddItem.notice));
+ }
+ } else {
+ // Otherwise show a notice
+ var dropdownItem = void 0;
+ var notice = void 0;
+
+ if (this._isSearching) {
+ notice = (0, _utils.isType)('Function', this.config.noResultsText) ? this.config.noResultsText() : this.config.noResultsText;
+
+ dropdownItem = this._getTemplate('notice', notice, 'no-results');
+ } else {
+ notice = (0, _utils.isType)('Function', this.config.noChoicesText) ? this.config.noChoicesText() : this.config.noChoicesText;
+
+ dropdownItem = this._getTemplate('notice', notice, 'no-choices');
+ }
+
+ this.choiceList.append(dropdownItem);
+ }
+ }
+ }, {
+ key: '_renderItems',
+ value: function _renderItems() {
+ // Get active items (items that can be selected)
+ var activeItems = this._store.activeItems || [];
+ // Clear list
+ this.itemList.clear();
+
+ if (activeItems.length) {
+ // Create a fragment to store our list items
+ // (so we don't have to update the DOM for each item)
+ var itemListFragment = this._createItemsFragment(activeItems);
+
+ // If we have items to add, append them
+ if (itemListFragment.childNodes) {
+ this.itemList.append(itemListFragment);
+ }
+ }
+ }
+
+ /* ===== End of Private functions ====== */
+
+ }], [{
+ key: '_generateConfig',
+ value: function _generateConfig(userConfig) {
+ var defaultConfig = _extends({}, _constants.DEFAULT_CONFIG, {
+ items: [],
+ choices: [],
+ classNames: _constants.DEFAULT_CLASSNAMES,
+ sortFn: _utils.sortByAlpha
+ });
+
+ return (0, _utils.extend)(defaultConfig, Choices.userDefaults, userConfig);
+ }
+ }]);
+
+ return Choices;
+}();
+
+Choices.userDefaults = {};
+
+// We cannot export default here due to Webpack: https://github.com/webpack/webpack/issues/3929
+module.exports = Choices;
+
+/***/ }),
+/* 36 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/*!
+ * Fuse.js v3.2.0 - Lightweight fuzzy-search (http://fusejs.io)
+ *
+ * Copyright (c) 2012-2017 Kirollos Risk (http://kiro.me)
+ * All Rights Reserved. Apache Software License 2.0
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+(function webpackUniversalModuleDefinition(root, factory) {
+ if(true)
+ module.exports = factory();
+ else if(typeof define === 'function' && define.amd)
+ define("Fuse", [], factory);
+ else if(typeof exports === 'object')
+ exports["Fuse"] = factory();
+ else
+ root["Fuse"] = factory();
+})(this, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ // The module cache
+/******/ var installedModules = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/
+/******/ // Check if module is in cache
+/******/ if(installedModules[moduleId]) {
+/******/ return installedModules[moduleId].exports;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = installedModules[moduleId] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = true;
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/******/
+/******/ // expose the modules object (__webpack_modules__)
+/******/ __webpack_require__.m = modules;
+/******/
+/******/ // expose the module cache
+/******/ __webpack_require__.c = installedModules;
+/******/
+/******/ // identity function for calling harmony imports with the correct context
+/******/ __webpack_require__.i = function(value) { return value; };
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, {
+/******/ configurable: false,
+/******/ enumerable: true,
+/******/ get: getter
+/******/ });
+/******/ }
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 8);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = function (obj) {
+ return Object.prototype.toString.call(obj) === '[object Array]';
+};
+
+/***/ }),
+/* 1 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var bitapRegexSearch = __webpack_require__(5);
+var bitapSearch = __webpack_require__(7);
+var patternAlphabet = __webpack_require__(4);
+
+var Bitap = function () {
+ function Bitap(pattern, _ref) {
+ var _ref$location = _ref.location,
+ location = _ref$location === undefined ? 0 : _ref$location,
+ _ref$distance = _ref.distance,
+ distance = _ref$distance === undefined ? 100 : _ref$distance,
+ _ref$threshold = _ref.threshold,
+ threshold = _ref$threshold === undefined ? 0.6 : _ref$threshold,
+ _ref$maxPatternLength = _ref.maxPatternLength,
+ maxPatternLength = _ref$maxPatternLength === undefined ? 32 : _ref$maxPatternLength,
+ _ref$isCaseSensitive = _ref.isCaseSensitive,
+ isCaseSensitive = _ref$isCaseSensitive === undefined ? false : _ref$isCaseSensitive,
+ _ref$tokenSeparator = _ref.tokenSeparator,
+ tokenSeparator = _ref$tokenSeparator === undefined ? / +/g : _ref$tokenSeparator,
+ _ref$findAllMatches = _ref.findAllMatches,
+ findAllMatches = _ref$findAllMatches === undefined ? false : _ref$findAllMatches,
+ _ref$minMatchCharLeng = _ref.minMatchCharLength,
+ minMatchCharLength = _ref$minMatchCharLeng === undefined ? 1 : _ref$minMatchCharLeng;
+
+ _classCallCheck(this, Bitap);
+
+ this.options = {
+ location: location,
+ distance: distance,
+ threshold: threshold,
+ maxPatternLength: maxPatternLength,
+ isCaseSensitive: isCaseSensitive,
+ tokenSeparator: tokenSeparator,
+ findAllMatches: findAllMatches,
+ minMatchCharLength: minMatchCharLength
+ };
+
+ this.pattern = this.options.isCaseSensitive ? pattern : pattern.toLowerCase();
+
+ if (this.pattern.length <= maxPatternLength) {
+ this.patternAlphabet = patternAlphabet(this.pattern);
+ }
+ }
+
+ _createClass(Bitap, [{
+ key: 'search',
+ value: function search(text) {
+ if (!this.options.isCaseSensitive) {
+ text = text.toLowerCase();
+ }
+
+ // Exact match
+ if (this.pattern === text) {
+ return {
+ isMatch: true,
+ score: 0,
+ matchedIndices: [[0, text.length - 1]]
+ };
+ }
+
+ // When pattern length is greater than the machine word length, just do a a regex comparison
+ var _options = this.options,
+ maxPatternLength = _options.maxPatternLength,
+ tokenSeparator = _options.tokenSeparator;
+
+ if (this.pattern.length > maxPatternLength) {
+ return bitapRegexSearch(text, this.pattern, tokenSeparator);
+ }
+
+ // Otherwise, use Bitap algorithm
+ var _options2 = this.options,
+ location = _options2.location,
+ distance = _options2.distance,
+ threshold = _options2.threshold,
+ findAllMatches = _options2.findAllMatches,
+ minMatchCharLength = _options2.minMatchCharLength;
+
+ return bitapSearch(text, this.pattern, this.patternAlphabet, {
+ location: location,
+ distance: distance,
+ threshold: threshold,
+ findAllMatches: findAllMatches,
+ minMatchCharLength: minMatchCharLength
+ });
+ }
+ }]);
+
+ return Bitap;
+}();
+
+// let x = new Bitap("od mn war", {})
+// let result = x.search("Old Man's War")
+// console.log(result)
+
+module.exports = Bitap;
+
+/***/ }),
+/* 2 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var isArray = __webpack_require__(0);
+
+var deepValue = function deepValue(obj, path, list) {
+ if (!path) {
+ // If there's no path left, we've gotten to the object we care about.
+ list.push(obj);
+ } else {
+ var dotIndex = path.indexOf('.');
+ var firstSegment = path;
+ var remaining = null;
+
+ if (dotIndex !== -1) {
+ firstSegment = path.slice(0, dotIndex);
+ remaining = path.slice(dotIndex + 1);
+ }
+
+ var value = obj[firstSegment];
+
+ if (value !== null && value !== undefined) {
+ if (!remaining && (typeof value === 'string' || typeof value === 'number')) {
+ list.push(value.toString());
+ } else if (isArray(value)) {
+ // Search each item in the array.
+ for (var i = 0, len = value.length; i < len; i += 1) {
+ deepValue(value[i], remaining, list);
+ }
+ } else if (remaining) {
+ // An object. Recurse further.
+ deepValue(value, remaining, list);
+ }
+ }
+ }
+
+ return list;
+};
+
+module.exports = function (obj, path) {
+ return deepValue(obj, path, []);
+};
+
+/***/ }),
+/* 3 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = function () {
+ var matchmask = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+ var minMatchCharLength = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+
+ var matchedIndices = [];
+ var start = -1;
+ var end = -1;
+ var i = 0;
+
+ for (var len = matchmask.length; i < len; i += 1) {
+ var match = matchmask[i];
+ if (match && start === -1) {
+ start = i;
+ } else if (!match && start !== -1) {
+ end = i - 1;
+ if (end - start + 1 >= minMatchCharLength) {
+ matchedIndices.push([start, end]);
+ }
+ start = -1;
+ }
+ }
+
+ // (i-1 - start) + 1 => i - start
+ if (matchmask[i - 1] && i - start >= minMatchCharLength) {
+ matchedIndices.push([start, i - 1]);
+ }
+
+ return matchedIndices;
+};
+
+/***/ }),
+/* 4 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = function (pattern) {
+ var mask = {};
+ var len = pattern.length;
+
+ for (var i = 0; i < len; i += 1) {
+ mask[pattern.charAt(i)] = 0;
+ }
+
+ for (var _i = 0; _i < len; _i += 1) {
+ mask[pattern.charAt(_i)] |= 1 << len - _i - 1;
+ }
+
+ return mask;
+};
+
+/***/ }),
+/* 5 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var SPECIAL_CHARS_REGEX = /[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g;
+
+module.exports = function (text, pattern) {
+ var tokenSeparator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : / +/g;
+
+ var regex = new RegExp(pattern.replace(SPECIAL_CHARS_REGEX, '\\$&').replace(tokenSeparator, '|'));
+ var matches = text.match(regex);
+ var isMatch = !!matches;
+ var matchedIndices = [];
+
+ if (isMatch) {
+ for (var i = 0, matchesLen = matches.length; i < matchesLen; i += 1) {
+ var match = matches[i];
+ matchedIndices.push([text.indexOf(match), match.length - 1]);
+ }
+ }
+
+ return {
+ // TODO: revisit this score
+ score: isMatch ? 0.5 : 1,
+ isMatch: isMatch,
+ matchedIndices: matchedIndices
+ };
+};
+
+/***/ }),
+/* 6 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+module.exports = function (pattern, _ref) {
+ var _ref$errors = _ref.errors,
+ errors = _ref$errors === undefined ? 0 : _ref$errors,
+ _ref$currentLocation = _ref.currentLocation,
+ currentLocation = _ref$currentLocation === undefined ? 0 : _ref$currentLocation,
+ _ref$expectedLocation = _ref.expectedLocation,
+ expectedLocation = _ref$expectedLocation === undefined ? 0 : _ref$expectedLocation,
+ _ref$distance = _ref.distance,
+ distance = _ref$distance === undefined ? 100 : _ref$distance;
+
+ var accuracy = errors / pattern.length;
+ var proximity = Math.abs(expectedLocation - currentLocation);
+
+ if (!distance) {
+ // Dodge divide by zero error.
+ return proximity ? 1.0 : accuracy;
+ }
+
+ return accuracy + proximity / distance;
+};
+
+/***/ }),
+/* 7 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var bitapScore = __webpack_require__(6);
+var matchedIndices = __webpack_require__(3);
+
+module.exports = function (text, pattern, patternAlphabet, _ref) {
+ var _ref$location = _ref.location,
+ location = _ref$location === undefined ? 0 : _ref$location,
+ _ref$distance = _ref.distance,
+ distance = _ref$distance === undefined ? 100 : _ref$distance,
+ _ref$threshold = _ref.threshold,
+ threshold = _ref$threshold === undefined ? 0.6 : _ref$threshold,
+ _ref$findAllMatches = _ref.findAllMatches,
+ findAllMatches = _ref$findAllMatches === undefined ? false : _ref$findAllMatches,
+ _ref$minMatchCharLeng = _ref.minMatchCharLength,
+ minMatchCharLength = _ref$minMatchCharLeng === undefined ? 1 : _ref$minMatchCharLeng;
+
+ var expectedLocation = location;
+ // Set starting location at beginning text and initialize the alphabet.
+ var textLen = text.length;
+ // Highest score beyond which we give up.
+ var currentThreshold = threshold;
+ // Is there a nearby exact match? (speedup)
+ var bestLocation = text.indexOf(pattern, expectedLocation);
+
+ var patternLen = pattern.length;
+
+ // a mask of the matches
+ var matchMask = [];
+ for (var i = 0; i < textLen; i += 1) {
+ matchMask[i] = 0;
+ }
+
+ if (bestLocation !== -1) {
+ var score = bitapScore(pattern, {
+ errors: 0,
+ currentLocation: bestLocation,
+ expectedLocation: expectedLocation,
+ distance: distance
+ });
+ currentThreshold = Math.min(score, currentThreshold);
+
+ // What about in the other direction? (speed up)
+ bestLocation = text.lastIndexOf(pattern, expectedLocation + patternLen);
+
+ if (bestLocation !== -1) {
+ var _score = bitapScore(pattern, {
+ errors: 0,
+ currentLocation: bestLocation,
+ expectedLocation: expectedLocation,
+ distance: distance
+ });
+ currentThreshold = Math.min(_score, currentThreshold);
+ }
+ }
+
+ // Reset the best location
+ bestLocation = -1;
+
+ var lastBitArr = [];
+ var finalScore = 1;
+ var binMax = patternLen + textLen;
+
+ var mask = 1 << patternLen - 1;
+
+ for (var _i = 0; _i < patternLen; _i += 1) {
+ // Scan for the best match; each iteration allows for one more error.
+ // Run a binary search to determine how far from the match location we can stray
+ // at this error level.
+ var binMin = 0;
+ var binMid = binMax;
+
+ while (binMin < binMid) {
+ var _score3 = bitapScore(pattern, {
+ errors: _i,
+ currentLocation: expectedLocation + binMid,
+ expectedLocation: expectedLocation,
+ distance: distance
+ });
+
+ if (_score3 <= currentThreshold) {
+ binMin = binMid;
+ } else {
+ binMax = binMid;
+ }
+
+ binMid = Math.floor((binMax - binMin) / 2 + binMin);
+ }
+
+ // Use the result from this iteration as the maximum for the next.
+ binMax = binMid;
+
+ var start = Math.max(1, expectedLocation - binMid + 1);
+ var finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen;
+
+ // Initialize the bit array
+ var bitArr = Array(finish + 2);
+
+ bitArr[finish + 1] = (1 << _i) - 1;
+
+ for (var j = finish; j >= start; j -= 1) {
+ var currentLocation = j - 1;
+ var charMatch = patternAlphabet[text.charAt(currentLocation)];
+
+ if (charMatch) {
+ matchMask[currentLocation] = 1;
+ }
+
+ // First pass: exact match
+ bitArr[j] = (bitArr[j + 1] << 1 | 1) & charMatch;
+
+ // Subsequent passes: fuzzy match
+ if (_i !== 0) {
+ bitArr[j] |= (lastBitArr[j + 1] | lastBitArr[j]) << 1 | 1 | lastBitArr[j + 1];
+ }
+
+ if (bitArr[j] & mask) {
+ finalScore = bitapScore(pattern, {
+ errors: _i,
+ currentLocation: currentLocation,
+ expectedLocation: expectedLocation,
+ distance: distance
+ });
+
+ // This match will almost certainly be better than any existing match.
+ // But check anyway.
+ if (finalScore <= currentThreshold) {
+ // Indeed it is
+ currentThreshold = finalScore;
+ bestLocation = currentLocation;
+
+ // Already passed `loc`, downhill from here on in.
+ if (bestLocation <= expectedLocation) {
+ break;
+ }
+
+ // When passing `bestLocation`, don't exceed our current distance from `expectedLocation`.
+ start = Math.max(1, 2 * expectedLocation - bestLocation);
+ }
+ }
+ }
+
+ // No hope for a (better) match at greater error levels.
+ var _score2 = bitapScore(pattern, {
+ errors: _i + 1,
+ currentLocation: expectedLocation,
+ expectedLocation: expectedLocation,
+ distance: distance
+ });
+
+ if (_score2 > currentThreshold) {
+ break;
+ }
+
+ lastBitArr = bitArr;
+ }
+
+ // Count exact matches (those with a score of 0) to be "almost" exact
+ return {
+ isMatch: bestLocation >= 0,
+ score: finalScore === 0 ? 0.001 : finalScore,
+ matchedIndices: matchedIndices(matchMask, minMatchCharLength)
+ };
+};
+
+/***/ }),
+/* 8 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Bitap = __webpack_require__(1);
+var deepValue = __webpack_require__(2);
+var isArray = __webpack_require__(0);
+
+var Fuse = function () {
+ function Fuse(list, _ref) {
+ var _ref$location = _ref.location,
+ location = _ref$location === undefined ? 0 : _ref$location,
+ _ref$distance = _ref.distance,
+ distance = _ref$distance === undefined ? 100 : _ref$distance,
+ _ref$threshold = _ref.threshold,
+ threshold = _ref$threshold === undefined ? 0.6 : _ref$threshold,
+ _ref$maxPatternLength = _ref.maxPatternLength,
+ maxPatternLength = _ref$maxPatternLength === undefined ? 32 : _ref$maxPatternLength,
+ _ref$caseSensitive = _ref.caseSensitive,
+ caseSensitive = _ref$caseSensitive === undefined ? false : _ref$caseSensitive,
+ _ref$tokenSeparator = _ref.tokenSeparator,
+ tokenSeparator = _ref$tokenSeparator === undefined ? / +/g : _ref$tokenSeparator,
+ _ref$findAllMatches = _ref.findAllMatches,
+ findAllMatches = _ref$findAllMatches === undefined ? false : _ref$findAllMatches,
+ _ref$minMatchCharLeng = _ref.minMatchCharLength,
+ minMatchCharLength = _ref$minMatchCharLeng === undefined ? 1 : _ref$minMatchCharLeng,
+ _ref$id = _ref.id,
+ id = _ref$id === undefined ? null : _ref$id,
+ _ref$keys = _ref.keys,
+ keys = _ref$keys === undefined ? [] : _ref$keys,
+ _ref$shouldSort = _ref.shouldSort,
+ shouldSort = _ref$shouldSort === undefined ? true : _ref$shouldSort,
+ _ref$getFn = _ref.getFn,
+ getFn = _ref$getFn === undefined ? deepValue : _ref$getFn,
+ _ref$sortFn = _ref.sortFn,
+ sortFn = _ref$sortFn === undefined ? function (a, b) {
+ return a.score - b.score;
+ } : _ref$sortFn,
+ _ref$tokenize = _ref.tokenize,
+ tokenize = _ref$tokenize === undefined ? false : _ref$tokenize,
+ _ref$matchAllTokens = _ref.matchAllTokens,
+ matchAllTokens = _ref$matchAllTokens === undefined ? false : _ref$matchAllTokens,
+ _ref$includeMatches = _ref.includeMatches,
+ includeMatches = _ref$includeMatches === undefined ? false : _ref$includeMatches,
+ _ref$includeScore = _ref.includeScore,
+ includeScore = _ref$includeScore === undefined ? false : _ref$includeScore,
+ _ref$verbose = _ref.verbose,
+ verbose = _ref$verbose === undefined ? false : _ref$verbose;
+
+ _classCallCheck(this, Fuse);
+
+ this.options = {
+ location: location,
+ distance: distance,
+ threshold: threshold,
+ maxPatternLength: maxPatternLength,
+ isCaseSensitive: caseSensitive,
+ tokenSeparator: tokenSeparator,
+ findAllMatches: findAllMatches,
+ minMatchCharLength: minMatchCharLength,
+ id: id,
+ keys: keys,
+ includeMatches: includeMatches,
+ includeScore: includeScore,
+ shouldSort: shouldSort,
+ getFn: getFn,
+ sortFn: sortFn,
+ verbose: verbose,
+ tokenize: tokenize,
+ matchAllTokens: matchAllTokens
+ };
+
+ this.setCollection(list);
+ }
+
+ _createClass(Fuse, [{
+ key: 'setCollection',
+ value: function setCollection(list) {
+ this.list = list;
+ return list;
+ }
+ }, {
+ key: 'search',
+ value: function search(pattern) {
+ this._log('---------\nSearch pattern: "' + pattern + '"');
+
+ var _prepareSearchers2 = this._prepareSearchers(pattern),
+ tokenSearchers = _prepareSearchers2.tokenSearchers,
+ fullSearcher = _prepareSearchers2.fullSearcher;
+
+ var _search2 = this._search(tokenSearchers, fullSearcher),
+ weights = _search2.weights,
+ results = _search2.results;
+
+ this._computeScore(weights, results);
+
+ if (this.options.shouldSort) {
+ this._sort(results);
+ }
+
+ return this._format(results);
+ }
+ }, {
+ key: '_prepareSearchers',
+ value: function _prepareSearchers() {
+ var pattern = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+
+ var tokenSearchers = [];
+
+ if (this.options.tokenize) {
+ // Tokenize on the separator
+ var tokens = pattern.split(this.options.tokenSeparator);
+ for (var i = 0, len = tokens.length; i < len; i += 1) {
+ tokenSearchers.push(new Bitap(tokens[i], this.options));
+ }
+ }
+
+ var fullSearcher = new Bitap(pattern, this.options);
+
+ return { tokenSearchers: tokenSearchers, fullSearcher: fullSearcher };
+ }
+ }, {
+ key: '_search',
+ value: function _search() {
+ var tokenSearchers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+ var fullSearcher = arguments[1];
+
+ var list = this.list;
+ var resultMap = {};
+ var results = [];
+
+ // Check the first item in the list, if it's a string, then we assume
+ // that every item in the list is also a string, and thus it's a flattened array.
+ if (typeof list[0] === 'string') {
+ // Iterate over every item
+ for (var i = 0, len = list.length; i < len; i += 1) {
+ this._analyze({
+ key: '',
+ value: list[i],
+ record: i,
+ index: i
+ }, {
+ resultMap: resultMap,
+ results: results,
+ tokenSearchers: tokenSearchers,
+ fullSearcher: fullSearcher
+ });
+ }
+
+ return { weights: null, results: results };
+ }
+
+ // Otherwise, the first item is an Object (hopefully), and thus the searching
+ // is done on the values of the keys of each item.
+ var weights = {};
+ for (var _i = 0, _len = list.length; _i < _len; _i += 1) {
+ var item = list[_i];
+ // Iterate over every key
+ for (var j = 0, keysLen = this.options.keys.length; j < keysLen; j += 1) {
+ var key = this.options.keys[j];
+ if (typeof key !== 'string') {
+ weights[key.name] = {
+ weight: 1 - key.weight || 1
+ };
+ if (key.weight <= 0 || key.weight > 1) {
+ throw new Error('Key weight has to be > 0 and <= 1');
+ }
+ key = key.name;
+ } else {
+ weights[key] = {
+ weight: 1
+ };
+ }
+
+ this._analyze({
+ key: key,
+ value: this.options.getFn(item, key),
+ record: item,
+ index: _i
+ }, {
+ resultMap: resultMap,
+ results: results,
+ tokenSearchers: tokenSearchers,
+ fullSearcher: fullSearcher
+ });
+ }
+ }
+
+ return { weights: weights, results: results };
+ }
+ }, {
+ key: '_analyze',
+ value: function _analyze(_ref2, _ref3) {
+ var key = _ref2.key,
+ _ref2$arrayIndex = _ref2.arrayIndex,
+ arrayIndex = _ref2$arrayIndex === undefined ? -1 : _ref2$arrayIndex,
+ value = _ref2.value,
+ record = _ref2.record,
+ index = _ref2.index;
+ var _ref3$tokenSearchers = _ref3.tokenSearchers,
+ tokenSearchers = _ref3$tokenSearchers === undefined ? [] : _ref3$tokenSearchers,
+ _ref3$fullSearcher = _ref3.fullSearcher,
+ fullSearcher = _ref3$fullSearcher === undefined ? [] : _ref3$fullSearcher,
+ _ref3$resultMap = _ref3.resultMap,
+ resultMap = _ref3$resultMap === undefined ? {} : _ref3$resultMap,
+ _ref3$results = _ref3.results,
+ results = _ref3$results === undefined ? [] : _ref3$results;
+
+ // Check if the texvaluet can be searched
+ if (value === undefined || value === null) {
+ return;
+ }
+
+ var exists = false;
+ var averageScore = -1;
+ var numTextMatches = 0;
+
+ if (typeof value === 'string') {
+ this._log('\nKey: ' + (key === '' ? '-' : key));
+
+ var mainSearchResult = fullSearcher.search(value);
+ this._log('Full text: "' + value + '", score: ' + mainSearchResult.score);
+
+ if (this.options.tokenize) {
+ var words = value.split(this.options.tokenSeparator);
+ var scores = [];
+
+ for (var i = 0; i < tokenSearchers.length; i += 1) {
+ var tokenSearcher = tokenSearchers[i];
+
+ this._log('\nPattern: "' + tokenSearcher.pattern + '"');
+
+ // let tokenScores = []
+ var hasMatchInText = false;
+
+ for (var j = 0; j < words.length; j += 1) {
+ var word = words[j];
+ var tokenSearchResult = tokenSearcher.search(word);
+ var obj = {};
+ if (tokenSearchResult.isMatch) {
+ obj[word] = tokenSearchResult.score;
+ exists = true;
+ hasMatchInText = true;
+ scores.push(tokenSearchResult.score);
+ } else {
+ obj[word] = 1;
+ if (!this.options.matchAllTokens) {
+ scores.push(1);
+ }
+ }
+ this._log('Token: "' + word + '", score: ' + obj[word]);
+ // tokenScores.push(obj)
+ }
+
+ if (hasMatchInText) {
+ numTextMatches += 1;
+ }
+ }
+
+ averageScore = scores[0];
+ var scoresLen = scores.length;
+ for (var _i2 = 1; _i2 < scoresLen; _i2 += 1) {
+ averageScore += scores[_i2];
+ }
+ averageScore = averageScore / scoresLen;
+
+ this._log('Token score average:', averageScore);
+ }
+
+ var finalScore = mainSearchResult.score;
+ if (averageScore > -1) {
+ finalScore = (finalScore + averageScore) / 2;
+ }
+
+ this._log('Score average:', finalScore);
+
+ var checkTextMatches = this.options.tokenize && this.options.matchAllTokens ? numTextMatches >= tokenSearchers.length : true;
+
+ this._log('\nCheck Matches: ' + checkTextMatches);
+
+ // If a match is found, add the item to , including its score
+ if ((exists || mainSearchResult.isMatch) && checkTextMatches) {
+ // Check if the item already exists in our results
+ var existingResult = resultMap[index];
+ if (existingResult) {
+ // Use the lowest score
+ // existingResult.score, bitapResult.score
+ existingResult.output.push({
+ key: key,
+ arrayIndex: arrayIndex,
+ value: value,
+ score: finalScore,
+ matchedIndices: mainSearchResult.matchedIndices
+ });
+ } else {
+ // Add it to the raw result list
+ resultMap[index] = {
+ item: record,
+ output: [{
+ key: key,
+ arrayIndex: arrayIndex,
+ value: value,
+ score: finalScore,
+ matchedIndices: mainSearchResult.matchedIndices
+ }]
+ };
+
+ results.push(resultMap[index]);
+ }
+ }
+ } else if (isArray(value)) {
+ for (var _i3 = 0, len = value.length; _i3 < len; _i3 += 1) {
+ this._analyze({
+ key: key,
+ arrayIndex: _i3,
+ value: value[_i3],
+ record: record,
+ index: index
+ }, {
+ resultMap: resultMap,
+ results: results,
+ tokenSearchers: tokenSearchers,
+ fullSearcher: fullSearcher
+ });
+ }
+ }
+ }
+ }, {
+ key: '_computeScore',
+ value: function _computeScore(weights, results) {
+ this._log('\n\nComputing score:\n');
+
+ for (var i = 0, len = results.length; i < len; i += 1) {
+ var output = results[i].output;
+ var scoreLen = output.length;
+
+ var totalScore = 0;
+ var bestScore = 1;
+
+ for (var j = 0; j < scoreLen; j += 1) {
+ var weight = weights ? weights[output[j].key].weight : 1;
+ var score = weight === 1 ? output[j].score : output[j].score || 0.001;
+ var nScore = score * weight;
+
+ if (weight !== 1) {
+ bestScore = Math.min(bestScore, nScore);
+ } else {
+ output[j].nScore = nScore;
+ totalScore += nScore;
+ }
+ }
+
+ results[i].score = bestScore === 1 ? totalScore / scoreLen : bestScore;
+
+ this._log(results[i]);
+ }
+ }
+ }, {
+ key: '_sort',
+ value: function _sort(results) {
+ this._log('\n\nSorting....');
+ results.sort(this.options.sortFn);
+ }
+ }, {
+ key: '_format',
+ value: function _format(results) {
+ var finalOutput = [];
+
+ this._log('\n\nOutput:\n\n', JSON.stringify(results));
+
+ var transformers = [];
+
+ if (this.options.includeMatches) {
+ transformers.push(function (result, data) {
+ var output = result.output;
+ data.matches = [];
+
+ for (var i = 0, len = output.length; i < len; i += 1) {
+ var item = output[i];
+
+ if (item.matchedIndices.length === 0) {
+ continue;
+ }
+
+ var obj = {
+ indices: item.matchedIndices,
+ value: item.value
+ };
+ if (item.key) {
+ obj.key = item.key;
+ }
+ if (item.hasOwnProperty('arrayIndex') && item.arrayIndex > -1) {
+ obj.arrayIndex = item.arrayIndex;
+ }
+ data.matches.push(obj);
+ }
+ });
+ }
+
+ if (this.options.includeScore) {
+ transformers.push(function (result, data) {
+ data.score = result.score;
+ });
+ }
+
+ for (var i = 0, len = results.length; i < len; i += 1) {
+ var result = results[i];
+
+ if (this.options.id) {
+ result.item = this.options.getFn(result.item, this.options.id)[0];
+ }
+
+ if (!transformers.length) {
+ finalOutput.push(result.item);
+ continue;
+ }
+
+ var data = {
+ item: result.item
+ };
+
+ for (var j = 0, _len2 = transformers.length; j < _len2; j += 1) {
+ transformers[j](result, data);
+ }
+
+ finalOutput.push(data);
+ }
+
+ return finalOutput;
+ }
+ }, {
+ key: '_log',
+ value: function _log() {
+ if (this.options.verbose) {
+ var _console;
+
+ (_console = console).log.apply(_console, arguments);
+ }
+ }
+ }]);
+
+ return Fuse;
+}();
+
+module.exports = Fuse;
+
+/***/ })
+/******/ ]);
+});
+//# sourceMappingURL=fuse.js.map
+
+/***/ }),
+/* 37 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+__webpack_require__(38);
+
+__webpack_require__(62);
+
+/***/ }),
+/* 38 */
+/***/ (function(module, exports, __webpack_require__) {
+
+__webpack_require__(39);
+__webpack_require__(55);
+module.exports = __webpack_require__(3).Array.from;
+
+
+/***/ }),
+/* 39 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $at = __webpack_require__(40)(true);
+
+// 21.1.3.27 String.prototype[@@iterator]()
+__webpack_require__(41)(String, 'String', function (iterated) {
+ this._t = String(iterated); // target
+ this._i = 0; // next index
+// 21.1.5.2.1 %StringIteratorPrototype%.next()
+}, function () {
+ var O = this._t;
+ var index = this._i;
+ var point;
+ if (index >= O.length) return { value: undefined, done: true };
+ point = $at(O, index);
+ this._i += point.length;
+ return { value: point, done: false };
+});
+
+
+/***/ }),
+/* 40 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var toInteger = __webpack_require__(10);
+var defined = __webpack_require__(11);
+// true -> String#at
+// false -> String#codePointAt
+module.exports = function (TO_STRING) {
+ return function (that, pos) {
+ var s = String(defined(that));
+ var i = toInteger(pos);
+ var l = s.length;
+ var a, b;
+ if (i < 0 || i >= l) return TO_STRING ? '' : undefined;
+ a = s.charCodeAt(i);
+ return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
+ ? TO_STRING ? s.charAt(i) : a
+ : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
+ };
+};
+
+
+/***/ }),
+/* 41 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var LIBRARY = __webpack_require__(17);
+var $export = __webpack_require__(18);
+var redefine = __webpack_require__(21);
+var hide = __webpack_require__(4);
+var Iterators = __webpack_require__(15);
+var $iterCreate = __webpack_require__(45);
+var setToStringTag = __webpack_require__(28);
+var getPrototypeOf = __webpack_require__(54);
+var ITERATOR = __webpack_require__(0)('iterator');
+var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`
+var FF_ITERATOR = '@@iterator';
+var KEYS = 'keys';
+var VALUES = 'values';
+
+var returnThis = function () { return this; };
+
+module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {
+ $iterCreate(Constructor, NAME, next);
+ var getMethod = function (kind) {
+ if (!BUGGY && kind in proto) return proto[kind];
+ switch (kind) {
+ case KEYS: return function keys() { return new Constructor(this, kind); };
+ case VALUES: return function values() { return new Constructor(this, kind); };
+ } return function entries() { return new Constructor(this, kind); };
+ };
+ var TAG = NAME + ' Iterator';
+ var DEF_VALUES = DEFAULT == VALUES;
+ var VALUES_BUG = false;
+ var proto = Base.prototype;
+ var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];
+ var $default = $native || getMethod(DEFAULT);
+ var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;
+ var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;
+ var methods, key, IteratorPrototype;
+ // Fix native
+ if ($anyNative) {
+ IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));
+ if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
+ // Set @@toStringTag to native iterators
+ setToStringTag(IteratorPrototype, TAG, true);
+ // fix for some old engines
+ if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') hide(IteratorPrototype, ITERATOR, returnThis);
+ }
+ }
+ // fix Array#{values, @@iterator}.name in V8 / FF
+ if (DEF_VALUES && $native && $native.name !== VALUES) {
+ VALUES_BUG = true;
+ $default = function values() { return $native.call(this); };
+ }
+ // Define iterator
+ if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {
+ hide(proto, ITERATOR, $default);
+ }
+ // Plug for library
+ Iterators[NAME] = $default;
+ Iterators[TAG] = returnThis;
+ if (DEFAULT) {
+ methods = {
+ values: DEF_VALUES ? $default : getMethod(VALUES),
+ keys: IS_SET ? $default : getMethod(KEYS),
+ entries: $entries
+ };
+ if (FORCED) for (key in methods) {
+ if (!(key in proto)) redefine(proto, key, methods[key]);
+ } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
+ }
+ return methods;
+};
+
+
+/***/ }),
+/* 42 */
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = !__webpack_require__(7) && !__webpack_require__(19)(function () {
+ return Object.defineProperty(__webpack_require__(20)('div'), 'a', { get: function () { return 7; } }).a != 7;
+});
+
+
+/***/ }),
+/* 43 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 7.1.1 ToPrimitive(input [, PreferredType])
+var isObject = __webpack_require__(12);
+// instead of the ES6 spec version, we didn't implement @@toPrimitive case
+// and the second argument - flag - preferred type is a string
+module.exports = function (it, S) {
+ if (!isObject(it)) return it;
+ var fn, val;
+ if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
+ if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
+ if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
+ throw TypeError("Can't convert object to primitive value");
+};
+
+
+/***/ }),
+/* 44 */
+/***/ (function(module, exports) {
+
+module.exports = function (it) {
+ if (typeof it != 'function') throw TypeError(it + ' is not a function!');
+ return it;
+};
+
+
+/***/ }),
+/* 45 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var create = __webpack_require__(46);
+var descriptor = __webpack_require__(13);
+var setToStringTag = __webpack_require__(28);
+var IteratorPrototype = {};
+
+// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
+__webpack_require__(4)(IteratorPrototype, __webpack_require__(0)('iterator'), function () { return this; });
+
+module.exports = function (Constructor, NAME, next) {
+ Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });
+ setToStringTag(Constructor, NAME + ' Iterator');
+};
+
+
+/***/ }),
+/* 46 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
+var anObject = __webpack_require__(6);
+var dPs = __webpack_require__(47);
+var enumBugKeys = __webpack_require__(27);
+var IE_PROTO = __webpack_require__(16)('IE_PROTO');
+var Empty = function () { /* empty */ };
+var PROTOTYPE = 'prototype';
+
+// Create object with fake `null` prototype: use iframe Object with cleared prototype
+var createDict = function () {
+ // Thrash, waste and sodomy: IE GC bug
+ var iframe = __webpack_require__(20)('iframe');
+ var i = enumBugKeys.length;
+ var lt = '<';
+ var gt = '>';
+ var iframeDocument;
+ iframe.style.display = 'none';
+ __webpack_require__(53).appendChild(iframe);
+ iframe.src = 'javascript:'; // eslint-disable-line no-script-url
+ // createDict = iframe.contentWindow.Object;
+ // html.removeChild(iframe);
+ iframeDocument = iframe.contentWindow.document;
+ iframeDocument.open();
+ iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
+ iframeDocument.close();
+ createDict = iframeDocument.F;
+ while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];
+ return createDict();
+};
+
+module.exports = Object.create || function create(O, Properties) {
+ var result;
+ if (O !== null) {
+ Empty[PROTOTYPE] = anObject(O);
+ result = new Empty();
+ Empty[PROTOTYPE] = null;
+ // add "__proto__" for Object.getPrototypeOf polyfill
+ result[IE_PROTO] = O;
+ } else result = createDict();
+ return Properties === undefined ? result : dPs(result, Properties);
+};
+
+
+/***/ }),
+/* 47 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var dP = __webpack_require__(5);
+var anObject = __webpack_require__(6);
+var getKeys = __webpack_require__(48);
+
+module.exports = __webpack_require__(7) ? Object.defineProperties : function defineProperties(O, Properties) {
+ anObject(O);
+ var keys = getKeys(Properties);
+ var length = keys.length;
+ var i = 0;
+ var P;
+ while (length > i) dP.f(O, P = keys[i++], Properties[P]);
+ return O;
+};
+
+
+/***/ }),
+/* 48 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.14 / 15.2.3.14 Object.keys(O)
+var $keys = __webpack_require__(49);
+var enumBugKeys = __webpack_require__(27);
+
+module.exports = Object.keys || function keys(O) {
+ return $keys(O, enumBugKeys);
+};
+
+
+/***/ }),
+/* 49 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var has = __webpack_require__(8);
+var toIObject = __webpack_require__(23);
+var arrayIndexOf = __webpack_require__(51)(false);
+var IE_PROTO = __webpack_require__(16)('IE_PROTO');
+
+module.exports = function (object, names) {
+ var O = toIObject(object);
+ var i = 0;
+ var result = [];
+ var key;
+ for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);
+ // Don't enum bug & hidden keys
+ while (names.length > i) if (has(O, key = names[i++])) {
+ ~arrayIndexOf(result, key) || result.push(key);
+ }
+ return result;
+};
+
+
+/***/ }),
+/* 50 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// fallback for non-array-like ES3 and non-enumerable old V8 strings
+var cof = __webpack_require__(24);
+// eslint-disable-next-line no-prototype-builtins
+module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
+ return cof(it) == 'String' ? it.split('') : Object(it);
+};
+
+
+/***/ }),
+/* 51 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// false -> Array#indexOf
+// true -> Array#includes
+var toIObject = __webpack_require__(23);
+var toLength = __webpack_require__(25);
+var toAbsoluteIndex = __webpack_require__(52);
+module.exports = function (IS_INCLUDES) {
+ return function ($this, el, fromIndex) {
+ var O = toIObject($this);
+ var length = toLength(O.length);
+ var index = toAbsoluteIndex(fromIndex, length);
+ var value;
+ // Array#includes uses SameValueZero equality algorithm
+ // eslint-disable-next-line no-self-compare
+ if (IS_INCLUDES && el != el) while (length > index) {
+ value = O[index++];
+ // eslint-disable-next-line no-self-compare
+ if (value != value) return true;
+ // Array#indexOf ignores holes, Array#includes - not
+ } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
+ if (O[index] === el) return IS_INCLUDES || index || 0;
+ } return !IS_INCLUDES && -1;
+ };
+};
+
+
+/***/ }),
+/* 52 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var toInteger = __webpack_require__(10);
+var max = Math.max;
+var min = Math.min;
+module.exports = function (index, length) {
+ index = toInteger(index);
+ return index < 0 ? max(index + length, 0) : min(index, length);
+};
+
+
+/***/ }),
+/* 53 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var document = __webpack_require__(2).document;
+module.exports = document && document.documentElement;
+
+
+/***/ }),
+/* 54 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
+var has = __webpack_require__(8);
+var toObject = __webpack_require__(29);
+var IE_PROTO = __webpack_require__(16)('IE_PROTO');
+var ObjectProto = Object.prototype;
+
+module.exports = Object.getPrototypeOf || function (O) {
+ O = toObject(O);
+ if (has(O, IE_PROTO)) return O[IE_PROTO];
+ if (typeof O.constructor == 'function' && O instanceof O.constructor) {
+ return O.constructor.prototype;
+ } return O instanceof Object ? ObjectProto : null;
+};
+
+
+/***/ }),
+/* 55 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var ctx = __webpack_require__(22);
+var $export = __webpack_require__(18);
+var toObject = __webpack_require__(29);
+var call = __webpack_require__(56);
+var isArrayIter = __webpack_require__(57);
+var toLength = __webpack_require__(25);
+var createProperty = __webpack_require__(58);
+var getIterFn = __webpack_require__(59);
+
+$export($export.S + $export.F * !__webpack_require__(61)(function (iter) { Array.from(iter); }), 'Array', {
+ // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
+ from: function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
+ var O = toObject(arrayLike);
+ var C = typeof this == 'function' ? this : Array;
+ var aLen = arguments.length;
+ var mapfn = aLen > 1 ? arguments[1] : undefined;
+ var mapping = mapfn !== undefined;
+ var index = 0;
+ var iterFn = getIterFn(O);
+ var length, result, step, iterator;
+ if (mapping) mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);
+ // if object isn't iterable or it's array with default iterator - use simple case
+ if (iterFn != undefined && !(C == Array && isArrayIter(iterFn))) {
+ for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++) {
+ createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);
+ }
+ } else {
+ length = toLength(O.length);
+ for (result = new C(length); length > index; index++) {
+ createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
+ }
+ }
+ result.length = index;
+ return result;
+ }
+});
+
+
+/***/ }),
+/* 56 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// call something on iterator step with safe closing on error
+var anObject = __webpack_require__(6);
+module.exports = function (iterator, fn, value, entries) {
+ try {
+ return entries ? fn(anObject(value)[0], value[1]) : fn(value);
+ // 7.4.6 IteratorClose(iterator, completion)
+ } catch (e) {
+ var ret = iterator['return'];
+ if (ret !== undefined) anObject(ret.call(iterator));
+ throw e;
+ }
+};
+
+
+/***/ }),
+/* 57 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// check on default Array iterator
+var Iterators = __webpack_require__(15);
+var ITERATOR = __webpack_require__(0)('iterator');
+var ArrayProto = Array.prototype;
+
+module.exports = function (it) {
+ return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
+};
+
+
+/***/ }),
+/* 58 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+var $defineProperty = __webpack_require__(5);
+var createDesc = __webpack_require__(13);
+
+module.exports = function (object, index, value) {
+ if (index in object) $defineProperty.f(object, index, createDesc(0, value));
+ else object[index] = value;
+};
+
+
+/***/ }),
+/* 59 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var classof = __webpack_require__(60);
+var ITERATOR = __webpack_require__(0)('iterator');
+var Iterators = __webpack_require__(15);
+module.exports = __webpack_require__(3).getIteratorMethod = function (it) {
+ if (it != undefined) return it[ITERATOR]
+ || it['@@iterator']
+ || Iterators[classof(it)];
+};
+
+
+/***/ }),
+/* 60 */
+/***/ (function(module, exports, __webpack_require__) {
+
+// getting tag from 19.1.3.6 Object.prototype.toString()
+var cof = __webpack_require__(24);
+var TAG = __webpack_require__(0)('toStringTag');
+// ES3 wrong here
+var ARG = cof(function () { return arguments; }()) == 'Arguments';
+
+// fallback for IE11 Script Access Denied error
+var tryGet = function (it, key) {
+ try {
+ return it[key];
+ } catch (e) { /* empty */ }
+};
+
+module.exports = function (it) {
+ var O, T, B;
+ return it === undefined ? 'Undefined' : it === null ? 'Null'
+ // @@toStringTag case
+ : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
+ // builtinTag case
+ : ARG ? cof(O)
+ // ES3 arguments fallback
+ : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
+};
+
+
+/***/ }),
+/* 61 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var ITERATOR = __webpack_require__(0)('iterator');
+var SAFE_CLOSING = false;
+
+try {
+ var riter = [7][ITERATOR]();
+ riter['return'] = function () { SAFE_CLOSING = true; };
+ // eslint-disable-next-line no-throw-literal
+ Array.from(riter, function () { throw 2; });
+} catch (e) { /* empty */ }
+
+module.exports = function (exec, skipClosing) {
+ if (!skipClosing && !SAFE_CLOSING) return false;
+ var safe = false;
+ try {
+ var arr = [7];
+ var iter = arr[ITERATOR]();
+ iter.next = function () { return { done: safe = true }; };
+ arr[ITERATOR] = function () { return iter; };
+ exec(arr);
+ } catch (e) { /* empty */ }
+ return safe;
+};
+
+
+/***/ }),
+/* 62 */
+/***/ (function(module, exports) {
+
+// Polyfill for creating CustomEvents on IE9/10/11
+
+// code pulled from:
+// https://github.com/d4tocchini/customevent-polyfill
+// https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent#Polyfill
+
+try {
+ var ce = new window.CustomEvent('test');
+ ce.preventDefault();
+ if (ce.defaultPrevented !== true) {
+ // IE has problems with .preventDefault() on custom events
+ // http://stackoverflow.com/questions/23349191
+ throw new Error('Could not prevent default');
+ }
+} catch(e) {
+ var CustomEvent = function(event, params) {
+ var evt, origPrevent;
+ params = params || {
+ bubbles: false,
+ cancelable: false,
+ detail: undefined
+ };
+
+ evt = document.createEvent("CustomEvent");
+ evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
+ origPrevent = evt.preventDefault;
+ evt.preventDefault = function () {
+ origPrevent.call(this);
+ try {
+ Object.defineProperty(this, 'defaultPrevented', {
+ get: function () {
+ return true;
+ }
+ });
+ } catch(e) {
+ this.defaultPrevented = true;
+ }
+ };
+ return evt;
+ };
+
+ CustomEvent.prototype = window.Event.prototype;
+ window.CustomEvent = CustomEvent; // expose definition to window
+}
+
+
+/***/ }),
+/* 63 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _redux = __webpack_require__(30);
+
+var _index = __webpack_require__(69);
+
+var _index2 = _interopRequireDefault(_index);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Store = function () {
+ function Store() {
+ _classCallCheck(this, Store);
+
+ this._store = (0, _redux.createStore)(_index2.default, window.devToolsExtension ? window.devToolsExtension() : undefined);
+ }
+
+ /**
+ * Subscribe store to function call (wrapped Redux method)
+ * @param {Function} onChange Function to trigger when state changes
+ * @return
+ */
+
+
+ _createClass(Store, [{
+ key: 'subscribe',
+ value: function subscribe(onChange) {
+ this._store.subscribe(onChange);
+ }
+
+ /**
+ * Dispatch event to store (wrapped Redux method)
+ * @param {Function} action Action function to trigger
+ * @return
+ */
+
+ }, {
+ key: 'dispatch',
+ value: function dispatch(action) {
+ this._store.dispatch(action);
+ }
+
+ /**
+ * Get store object (wrapping Redux method)
+ * @return {Object} State
+ */
+
+ }, {
+ key: 'getChoiceById',
+
+
+ /**
+ * Get single choice by it's ID
+ * @return {Object} Found choice
+ */
+ value: function getChoiceById(id) {
+ if (id) {
+ var choices = this.activeChoices;
+ var foundChoice = choices.find(function (choice) {
+ return choice.id === parseInt(id, 10);
+ });
+ return foundChoice;
+ }
+ return false;
+ }
+
+ /**
+ * Get group by group id
+ * @param {Number} id Group ID
+ * @return {Object} Group data
+ */
+
+ }, {
+ key: 'getGroupById',
+ value: function getGroupById(id) {
+ return this.groups.find(function (group) {
+ return group.id === parseInt(id, 10);
+ });
+ }
+ }, {
+ key: 'state',
+ get: function get() {
+ return this._store.getState();
+ }
+
+ /**
+ * Get items from store
+ * @return {Array} Item objects
+ */
+
+ }, {
+ key: 'items',
+ get: function get() {
+ return this.state.items;
+ }
+
+ /**
+ * Get active items from store
+ * @return {Array} Item objects
+ */
+
+ }, {
+ key: 'activeItems',
+ get: function get() {
+ return this.items.filter(function (item) {
+ return item.active === true;
+ });
+ }
+
+ /**
+ * Get highlighted items from store
+ * @return {Array} Item objects
+ */
+
+ }, {
+ key: 'highlightedActiveItems',
+ get: function get() {
+ return this.items.filter(function (item) {
+ return item.active && item.highlighted;
+ });
+ }
+
+ /**
+ * Get choices from store
+ * @return {Array} Option objects
+ */
+
+ }, {
+ key: 'choices',
+ get: function get() {
+ return this.state.choices;
+ }
+
+ /**
+ * Get active choices from store
+ * @return {Array} Option objects
+ */
+
+ }, {
+ key: 'activeChoices',
+ get: function get() {
+ var choices = this.choices;
+ var values = choices.filter(function (choice) {
+ return choice.active === true;
+ });
+
+ return values;
+ }
+
+ /**
+ * Get selectable choices from store
+ * @return {Array} Option objects
+ */
+
+ }, {
+ key: 'selectableChoices',
+ get: function get() {
+ return this.choices.filter(function (choice) {
+ return choice.disabled !== true;
+ });
+ }
+
+ /**
+ * Get choices that can be searched (excluding placeholders)
+ * @return {Array} Option objects
+ */
+
+ }, {
+ key: 'searchableChoices',
+ get: function get() {
+ return this.selectableChoices.filter(function (choice) {
+ return choice.placeholder !== true;
+ });
+ }
+
+ /**
+ * Get placeholder choice from store
+ * @return {Object} Found placeholder
+ */
+
+ }, {
+ key: 'placeholderChoice',
+ get: function get() {
+ return [].concat(_toConsumableArray(this.choices)).reverse().find(function (choice) {
+ return choice.placeholder === true;
+ });
+ }
+
+ /**
+ * Get groups from store
+ * @return {Array} Group objects
+ */
+
+ }, {
+ key: 'groups',
+ get: function get() {
+ return this.state.groups;
+ }
+
+ /**
+ * Get active groups from store
+ * @return {Array} Group objects
+ */
+
+ }, {
+ key: 'activeGroups',
+ get: function get() {
+ var groups = this.groups;
+ var choices = this.choices;
+
+ return groups.filter(function (group) {
+ var isActive = group.active === true && group.disabled === false;
+ var hasActiveOptions = choices.some(function (choice) {
+ return choice.active === true && choice.disabled === false;
+ });
+ return isActive && hasActiveOptions;
+ }, []);
+ }
+ }]);
+
+ return Store;
+}();
+
+exports.default = Store;
+
+/***/ }),
+/* 64 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+/* harmony default export */ __webpack_exports__["a"] = (freeGlobal);
+
+/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(31)))
+
+/***/ }),
+/* 65 */
+/***/ (function(module, exports, __webpack_require__) {
+
+module.exports = __webpack_require__(66);
+
+
+/***/ }),
+/* 66 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global, module) {
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _ponyfill = __webpack_require__(68);
+
+var _ponyfill2 = _interopRequireDefault(_ponyfill);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+var root; /* global window */
+
+
+if (typeof self !== 'undefined') {
+ root = self;
+} else if (typeof window !== 'undefined') {
+ root = window;
+} else if (typeof global !== 'undefined') {
+ root = global;
+} else if (true) {
+ root = module;
+} else {
+ root = Function('return this')();
+}
+
+var result = (0, _ponyfill2['default'])(root);
+exports['default'] = result;
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(31), __webpack_require__(67)(module)))
+
+/***/ }),
+/* 67 */
+/***/ (function(module, exports) {
+
+module.exports = function(module) {
+ if(!module.webpackPolyfill) {
+ module.deprecate = function() {};
+ module.paths = [];
+ // module.parent = undefined by default
+ if(!module.children) module.children = [];
+ Object.defineProperty(module, "loaded", {
+ enumerable: true,
+ get: function() {
+ return module.l;
+ }
+ });
+ Object.defineProperty(module, "id", {
+ enumerable: true,
+ get: function() {
+ return module.i;
+ }
+ });
+ module.webpackPolyfill = 1;
+ }
+ return module;
+};
+
+
+/***/ }),
+/* 68 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports['default'] = symbolObservablePonyfill;
+function symbolObservablePonyfill(root) {
+ var result;
+ var _Symbol = root.Symbol;
+
+ if (typeof _Symbol === 'function') {
+ if (_Symbol.observable) {
+ result = _Symbol.observable;
+ } else {
+ result = _Symbol('observable');
+ _Symbol.observable = result;
+ }
+ } else {
+ result = '@@observable';
+ }
+
+ return result;
+};
+
+/***/ }),
+/* 69 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _redux = __webpack_require__(30);
+
+var _items = __webpack_require__(70);
+
+var _items2 = _interopRequireDefault(_items);
+
+var _groups = __webpack_require__(71);
+
+var _groups2 = _interopRequireDefault(_groups);
+
+var _choices = __webpack_require__(72);
+
+var _choices2 = _interopRequireDefault(_choices);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var appReducer = (0, _redux.combineReducers)({
+ items: _items2.default,
+ groups: _groups2.default,
+ choices: _choices2.default
+});
+
+var rootReducer = function rootReducer(passedState, action) {
+ var state = passedState;
+ // If we are clearing all items, groups and options we reassign
+ // state and then pass that state to our proper reducer. This isn't
+ // mutating our actual state
+ // See: http://stackoverflow.com/a/35641992
+ if (action.type === 'CLEAR_ALL') {
+ state = undefined;
+ }
+
+ return appReducer(state, action);
+};
+
+exports.default = rootReducer;
+
+/***/ }),
+/* 70 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = items;
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+var defaultState = exports.defaultState = [];
+
+function items() {
+ var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultState;
+ var action = arguments[1];
+
+ switch (action.type) {
+ case 'ADD_ITEM':
+ {
+ // Add object to items array
+ var newState = [].concat(_toConsumableArray(state), [{
+ id: action.id,
+ choiceId: action.choiceId,
+ groupId: action.groupId,
+ value: action.value,
+ label: action.label,
+ active: true,
+ highlighted: false,
+ customProperties: action.customProperties,
+ placeholder: action.placeholder || false,
+ keyCode: null
+ }]);
+
+ return newState.map(function (obj) {
+ var item = obj;
+ item.highlighted = false;
+ return item;
+ });
+ }
+
+ case 'REMOVE_ITEM':
+ {
+ // Set item to inactive
+ return state.map(function (obj) {
+ var item = obj;
+ if (item.id === action.id) {
+ item.active = false;
+ }
+ return item;
+ });
+ }
+
+ case 'HIGHLIGHT_ITEM':
+ {
+ return state.map(function (obj) {
+ var item = obj;
+ if (item.id === action.id) {
+ item.highlighted = action.highlighted;
+ }
+ return item;
+ });
+ }
+
+ default:
+ {
+ return state;
+ }
+ }
+}
+
+/***/ }),
+/* 71 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = groups;
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+var defaultState = exports.defaultState = [];
+
+function groups() {
+ var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultState;
+ var action = arguments[1];
+
+ switch (action.type) {
+ case 'ADD_GROUP':
+ {
+ return [].concat(_toConsumableArray(state), [{
+ id: action.id,
+ value: action.value,
+ active: action.active,
+ disabled: action.disabled
+ }]);
+ }
+
+ case 'CLEAR_CHOICES':
+ {
+ return [];
+ }
+
+ default:
+ {
+ return state;
+ }
+ }
+}
+
+/***/ }),
+/* 72 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.default = choices;
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+var defaultState = exports.defaultState = [];
+
+function choices() {
+ var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultState;
+ var action = arguments[1];
+
+ switch (action.type) {
+ case 'ADD_CHOICE':
+ {
+ /*
+ A disabled choice appears in the choice dropdown but cannot be selected
+ A selected choice has been added to the passed input's value (added as an item)
+ An active choice appears within the choice dropdown
+ */
+ return [].concat(_toConsumableArray(state), [{
+ id: action.id,
+ elementId: action.elementId,
+ groupId: action.groupId,
+ value: action.value,
+ label: action.label || action.value,
+ disabled: action.disabled || false,
+ selected: false,
+ active: true,
+ score: 9999,
+ customProperties: action.customProperties,
+ placeholder: action.placeholder || false,
+ keyCode: null
+ }]);
+ }
+
+ case 'ADD_ITEM':
+ {
+ // If all choices need to be activated
+ if (action.activateOptions) {
+ return state.map(function (obj) {
+ var choice = obj;
+ choice.active = action.active;
+ return choice;
+ });
+ }
+
+ // When an item is added and it has an associated choice,
+ // we want to disable it so it can't be chosen again
+ if (action.choiceId > -1) {
+ return state.map(function (obj) {
+ var choice = obj;
+ if (choice.id === parseInt(action.choiceId, 10)) {
+ choice.selected = true;
+ }
+ return choice;
+ });
+ }
+
+ return state;
+ }
+
+ case 'REMOVE_ITEM':
+ {
+ // When an item is removed and it has an associated choice,
+ // we want to re-enable it so it can be chosen again
+ if (action.choiceId > -1) {
+ return state.map(function (obj) {
+ var choice = obj;
+ if (choice.id === parseInt(action.choiceId, 10)) {
+ choice.selected = false;
+ }
+ return choice;
+ });
+ }
+
+ return state;
+ }
+
+ case 'FILTER_CHOICES':
+ {
+ return state.map(function (obj) {
+ var choice = obj;
+ // Set active state based on whether choice is
+ // within filtered results
+ choice.active = action.results.some(function (_ref) {
+ var item = _ref.item,
+ score = _ref.score;
+
+ if (item.id === choice.id) {
+ choice.score = score;
+ return true;
+ }
+ return false;
+ });
+
+ return choice;
+ });
+ }
+
+ case 'ACTIVATE_CHOICES':
+ {
+ return state.map(function (obj) {
+ var choice = obj;
+ choice.active = action.active;
+ return choice;
+ });
+ }
+
+ case 'CLEAR_CHOICES':
+ {
+ return defaultState;
+ }
+
+ default:
+ {
+ return state;
+ }
+ }
+}
+
+/***/ }),
+/* 73 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.WrappedSelect = exports.WrappedInput = exports.List = exports.Input = exports.Container = exports.Dropdown = undefined;
+
+var _dropdown = __webpack_require__(74);
+
+var _dropdown2 = _interopRequireDefault(_dropdown);
+
+var _container = __webpack_require__(75);
+
+var _container2 = _interopRequireDefault(_container);
+
+var _input = __webpack_require__(76);
+
+var _input2 = _interopRequireDefault(_input);
+
+var _list = __webpack_require__(77);
+
+var _list2 = _interopRequireDefault(_list);
+
+var _wrappedInput = __webpack_require__(78);
+
+var _wrappedInput2 = _interopRequireDefault(_wrappedInput);
+
+var _wrappedSelect = __webpack_require__(79);
+
+var _wrappedSelect2 = _interopRequireDefault(_wrappedSelect);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.Dropdown = _dropdown2.default;
+exports.Container = _container2.default;
+exports.Input = _input2.default;
+exports.List = _list2.default;
+exports.WrappedInput = _wrappedInput2.default;
+exports.WrappedSelect = _wrappedSelect2.default;
+
+/***/ }),
+/* 74 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Dropdown = function () {
+ function Dropdown(_ref) {
+ var element = _ref.element,
+ type = _ref.type,
+ classNames = _ref.classNames;
+
+ _classCallCheck(this, Dropdown);
+
+ Object.assign(this, { element: element, type: type, classNames: classNames });
+
+ this.isActive = false;
+ }
+
+ /**
+ * Determine how far the top of our element is from
+ * the top of the window
+ * @return {Number} Vertical position
+ */
+
+
+ _createClass(Dropdown, [{
+ key: 'distanceFromTopWindow',
+ value: function distanceFromTopWindow() {
+ this.dimensions = this.element.getBoundingClientRect();
+ this.position = Math.ceil(this.dimensions.top + window.pageYOffset + this.element.offsetHeight);
+ return this.position;
+ }
+
+ /**
+ * Find element that matches passed selector
+ * @return {HTMLElement}
+ */
+
+ }, {
+ key: 'getChild',
+ value: function getChild(selector) {
+ return this.element.querySelector(selector);
+ }
+
+ /**
+ * Show dropdown to user by adding active state class
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'show',
+ value: function show() {
+ this.element.classList.add(this.classNames.activeState);
+ this.element.setAttribute('aria-expanded', 'true');
+ this.isActive = true;
+ return this;
+ }
+
+ /**
+ * Hide dropdown from user
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'hide',
+ value: function hide() {
+ this.element.classList.remove(this.classNames.activeState);
+ this.element.setAttribute('aria-expanded', 'false');
+ this.isActive = false;
+ return this;
+ }
+ }]);
+
+ return Dropdown;
+}();
+
+exports.default = Dropdown;
+
+/***/ }),
+/* 75 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _utils = __webpack_require__(1);
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Container = function () {
+ function Container(_ref) {
+ var element = _ref.element,
+ type = _ref.type,
+ classNames = _ref.classNames,
+ position = _ref.position;
+
+ _classCallCheck(this, Container);
+
+ Object.assign(this, { element: element, classNames: classNames, type: type, position: position });
+
+ this.isOpen = false;
+ this.isFlipped = false;
+ this.isFocussed = false;
+ this.isDisabled = false;
+ this.isLoading = false;
+
+ this._onFocus = this._onFocus.bind(this);
+ this._onBlur = this._onBlur.bind(this);
+ }
+
+ /**
+ * Add event listeners
+ */
+
+
+ _createClass(Container, [{
+ key: 'addEventListeners',
+ value: function addEventListeners() {
+ this.element.addEventListener('focus', this._onFocus);
+ this.element.addEventListener('blur', this._onBlur);
+ }
+
+ /**
+ * Remove event listeners
+ */
+
+ /** */
+
+ }, {
+ key: 'removeEventListeners',
+ value: function removeEventListeners() {
+ this.element.removeEventListener('focus', this._onFocus);
+ this.element.removeEventListener('blur', this._onBlur);
+ }
+
+ /**
+ * Determine whether container should be flipped
+ * based on passed dropdown position
+ * @param {Number} dropdownPos
+ * @returns
+ */
+
+ }, {
+ key: 'shouldFlip',
+ value: function shouldFlip(dropdownPos) {
+ var windowHeight = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (0, _utils.getWindowHeight)();
+
+ if (dropdownPos === undefined) {
+ return false;
+ }
+
+ // If flip is enabled and the dropdown bottom position is
+ // greater than the window height flip the dropdown.
+ var shouldFlip = false;
+ if (this.position === 'auto') {
+ shouldFlip = dropdownPos >= windowHeight;
+ } else if (this.position === 'top') {
+ shouldFlip = true;
+ }
+
+ return shouldFlip;
+ }
+
+ /**
+ * Set active descendant attribute
+ * @param {Number} activeDescendant ID of active descendant
+ */
+
+ }, {
+ key: 'setActiveDescendant',
+ value: function setActiveDescendant(activeDescendantID) {
+ this.element.setAttribute('aria-activedescendant', activeDescendantID);
+ }
+
+ /**
+ * Remove active descendant attribute
+ */
+
+ }, {
+ key: 'removeActiveDescendant',
+ value: function removeActiveDescendant() {
+ this.element.removeAttribute('aria-activedescendant');
+ }
+ }, {
+ key: 'open',
+ value: function open(dropdownPos) {
+ this.element.classList.add(this.classNames.openState);
+ this.element.setAttribute('aria-expanded', 'true');
+ this.isOpen = true;
+
+ if (this.shouldFlip(dropdownPos)) {
+ this.element.classList.add(this.classNames.flippedState);
+ this.isFlipped = true;
+ }
+ }
+ }, {
+ key: 'close',
+ value: function close() {
+ this.element.classList.remove(this.classNames.openState);
+ this.element.setAttribute('aria-expanded', 'false');
+ this.removeActiveDescendant();
+ this.isOpen = false;
+
+ // A dropdown flips if it does not have space within the page
+ if (this.isFlipped) {
+ this.element.classList.remove(this.classNames.flippedState);
+ this.isFlipped = false;
+ }
+ }
+ }, {
+ key: 'focus',
+ value: function focus() {
+ if (!this.isFocussed) {
+ this.element.focus();
+ }
+ }
+ }, {
+ key: 'addFocusState',
+ value: function addFocusState() {
+ this.element.classList.add(this.classNames.focusState);
+ }
+ }, {
+ key: 'removeFocusState',
+ value: function removeFocusState() {
+ this.element.classList.remove(this.classNames.focusState);
+ }
+
+ /**
+ * Remove disabled state
+ */
+
+ }, {
+ key: 'enable',
+ value: function enable() {
+ this.element.classList.remove(this.classNames.disabledState);
+ this.element.removeAttribute('aria-disabled');
+ if (this.type === 'select-one') {
+ this.element.setAttribute('tabindex', '0');
+ }
+ this.isDisabled = false;
+ }
+
+ /**
+ * Set disabled state
+ */
+
+ }, {
+ key: 'disable',
+ value: function disable() {
+ this.element.classList.add(this.classNames.disabledState);
+ this.element.setAttribute('aria-disabled', 'true');
+ if (this.type === 'select-one') {
+ this.element.setAttribute('tabindex', '-1');
+ }
+ this.isDisabled = true;
+ }
+ }, {
+ key: 'wrap',
+ value: function wrap(element) {
+ (0, _utils.wrap)(element, this.element);
+ }
+ }, {
+ key: 'unwrap',
+ value: function unwrap(element) {
+ // Move passed element outside this element
+ this.element.parentNode.insertBefore(element, this.element);
+ // Remove this element
+ this.element.parentNode.removeChild(this.element);
+ }
+
+ /**
+ * Add loading state to element
+ */
+
+ }, {
+ key: 'addLoadingState',
+ value: function addLoadingState() {
+ this.element.classList.add(this.classNames.loadingState);
+ this.element.setAttribute('aria-busy', 'true');
+ this.isLoading = true;
+ }
+
+ /**
+ * Remove loading state from element
+ */
+
+ }, {
+ key: 'removeLoadingState',
+ value: function removeLoadingState() {
+ this.element.classList.remove(this.classNames.loadingState);
+ this.element.removeAttribute('aria-busy');
+ this.isLoading = false;
+ }
+
+ /**
+ * Set focussed state
+ */
+
+ }, {
+ key: '_onFocus',
+ value: function _onFocus() {
+ this.isFocussed = true;
+ }
+
+ /**
+ * Remove blurred state
+ */
+
+ }, {
+ key: '_onBlur',
+ value: function _onBlur() {
+ this.isFocussed = false;
+ }
+ }]);
+
+ return Container;
+}();
+
+exports.default = Container;
+
+/***/ }),
+/* 76 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _utils = __webpack_require__(1);
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var Input = function () {
+ function Input(_ref) {
+ var element = _ref.element,
+ type = _ref.type,
+ classNames = _ref.classNames,
+ placeholderValue = _ref.placeholderValue;
+
+ _classCallCheck(this, Input);
+
+ Object.assign(this, { element: element, type: type, classNames: classNames, placeholderValue: placeholderValue });
+
+ this.element = element;
+ this.classNames = classNames;
+ this.isFocussed = this.element === document.activeElement;
+ this.isDisabled = false;
+
+ // Bind event listeners
+ this._onPaste = this._onPaste.bind(this);
+ this._onInput = this._onInput.bind(this);
+ this._onFocus = this._onFocus.bind(this);
+ this._onBlur = this._onBlur.bind(this);
+ }
+
+ _createClass(Input, [{
+ key: 'addEventListeners',
+ value: function addEventListeners() {
+ this.element.addEventListener('input', this._onInput);
+ this.element.addEventListener('paste', this._onPaste);
+ this.element.addEventListener('focus', this._onFocus);
+ this.element.addEventListener('blur', this._onBlur);
+ }
+ }, {
+ key: 'removeEventListeners',
+ value: function removeEventListeners() {
+ this.element.removeEventListener('input', this._onInput);
+ this.element.removeEventListener('paste', this._onPaste);
+ this.element.removeEventListener('focus', this._onFocus);
+ this.element.removeEventListener('blur', this._onBlur);
+ }
+ }, {
+ key: 'enable',
+ value: function enable() {
+ this.element.removeAttribute('disabled');
+ this.isDisabled = false;
+ }
+ }, {
+ key: 'disable',
+ value: function disable() {
+ this.element.setAttribute('disabled', '');
+ this.isDisabled = true;
+ }
+ }, {
+ key: 'focus',
+ value: function focus() {
+ if (!this.isFocussed) {
+ this.element.focus();
+ }
+ }
+ }, {
+ key: 'blur',
+ value: function blur() {
+ if (this.isFocussed) {
+ this.element.blur();
+ }
+ }
+
+ /**
+ * Set value of input to blank
+ * @return {Object} Class instance
+ * @public
+ */
+
+ }, {
+ key: 'clear',
+ value: function clear() {
+ var setWidth = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+
+ if (this.element.value) {
+ this.element.value = '';
+ }
+
+ if (setWidth) {
+ this.setWidth();
+ }
+
+ return this;
+ }
+
+ /**
+ * Set the correct input width based on placeholder
+ * value or input value
+ * @return
+ */
+
+ }, {
+ key: 'setWidth',
+ value: function setWidth(enforceWidth) {
+ if (this._placeholderValue) {
+ // If there is a placeholder, we only want to set the width of the input when it is a greater
+ // length than 75% of the placeholder. This stops the input jumping around.
+ if (this.element.value && this.element.value.length >= this._placeholderValue.length / 1.25 || enforceWidth) {
+ this.element.style.width = this.calcWidth();
+ }
+ } else {
+ // If there is no placeholder, resize input to contents
+ this.element.style.width = this.calcWidth();
+ }
+ }
+ }, {
+ key: 'calcWidth',
+ value: function calcWidth() {
+ return (0, _utils.calcWidthOfInput)(this.element);
+ }
+ }, {
+ key: 'setActiveDescendant',
+ value: function setActiveDescendant(activeDescendantID) {
+ this.element.setAttribute('aria-activedescendant', activeDescendantID);
+ }
+ }, {
+ key: 'removeActiveDescendant',
+ value: function removeActiveDescendant() {
+ this.element.removeAttribute('aria-activedescendant');
+ }
+
+ /**
+ * Input event
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_onInput',
+ value: function _onInput() {
+ if (this.type !== 'select-one') {
+ this.setWidth();
+ }
+ }
+
+ /**
+ * Paste event
+ * @param {Object} e Event
+ * @return
+ * @private
+ */
+
+ }, {
+ key: '_onPaste',
+ value: function _onPaste(e) {
+ // Disable pasting into the input if option has been set
+ if (e.target === this.element && this.preventPaste) {
+ e.preventDefault();
+ }
+ }
+ }, {
+ key: '_onFocus',
+ value: function _onFocus() {
+ this.isFocussed = true;
+ }
+ }, {
+ key: '_onBlur',
+ value: function _onBlur() {
+ this.isFocussed = false;
+ }
+ }, {
+ key: 'placeholder',
+ set: function set(placeholder) {
+ this.element.placeholder = placeholder;
+ }
+ }, {
+ key: 'value',
+ set: function set(value) {
+ this.element.value = value;
+ },
+ get: function get() {
+ return this.element.value;
+ }
+ }]);
+
+ return Input;
+}();
+
+exports.default = Input;
+
+/***/ }),
+/* 77 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var List = function () {
+ function List(_ref) {
+ var element = _ref.element;
+
+ _classCallCheck(this, List);
+
+ Object.assign(this, { element: element });
+
+ this.scrollPos = this.element.scrollTop;
+ this.height = this.element.offsetHeight;
+ this.hasChildren = !!this.element.children;
+ }
+
+ /**
+ * Clear List contents
+ */
+
+
+ _createClass(List, [{
+ key: 'clear',
+ value: function clear() {
+ this.element.innerHTML = '';
+ }
+
+ /**
+ * Scroll to passed position on Y axis
+ */
+
+ }, {
+ key: 'scrollTo',
+ value: function scrollTo() {
+ var scrollPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+
+ this.element.scrollTop = scrollPos;
+ }
+ /**
+ * Append node to element
+ */
+
+ }, {
+ key: 'append',
+ value: function append(node) {
+ this.element.appendChild(node);
+ }
+
+ /**
+ * Find element that matches passed selector
+ * @return {HTMLElement}
+ */
+
+ }, {
+ key: 'getChild',
+ value: function getChild(selector) {
+ return this.element.querySelector(selector);
+ }
+ }]);
+
+ return List;
+}();
+
+exports.default = List;
+
+/***/ }),
+/* 78 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+var _wrappedElement = __webpack_require__(32);
+
+var _wrappedElement2 = _interopRequireDefault(_wrappedElement);
+
+var _utils = __webpack_require__(1);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var WrappedInput = function (_WrappedElement) {
+ _inherits(WrappedInput, _WrappedElement);
+
+ function WrappedInput(_ref) {
+ var element = _ref.element,
+ classNames = _ref.classNames,
+ delimiter = _ref.delimiter;
+
+ _classCallCheck(this, WrappedInput);
+
+ var _this = _possibleConstructorReturn(this, (WrappedInput.__proto__ || Object.getPrototypeOf(WrappedInput)).call(this, { element: element, classNames: classNames }));
+
+ _this.delimiter = delimiter;
+ return _this;
+ }
+
+ _createClass(WrappedInput, [{
+ key: 'value',
+ set: function set(items) {
+ var itemsFiltered = (0, _utils.reduceToValues)(items);
+ var itemsFilteredString = itemsFiltered.join(this.delimiter);
+
+ this.element.setAttribute('value', itemsFilteredString);
+ this.element.value = itemsFilteredString;
+ }
+
+ // @todo figure out why we need this? Perhaps a babel issue
+ ,
+ get: function get() {
+ return _get(WrappedInput.prototype.__proto__ || Object.getPrototypeOf(WrappedInput.prototype), 'value', this);
+ }
+ }]);
+
+ return WrappedInput;
+}(_wrappedElement2.default);
+
+exports.default = WrappedInput;
+
+/***/ }),
+/* 79 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _wrappedElement = __webpack_require__(32);
+
+var _wrappedElement2 = _interopRequireDefault(_wrappedElement);
+
+var _templates = __webpack_require__(33);
+
+var _templates2 = _interopRequireDefault(_templates);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var WrappedSelect = function (_WrappedElement) {
+ _inherits(WrappedSelect, _WrappedElement);
+
+ function WrappedSelect(_ref) {
+ var element = _ref.element,
+ classNames = _ref.classNames;
+
+ _classCallCheck(this, WrappedSelect);
+
+ return _possibleConstructorReturn(this, (WrappedSelect.__proto__ || Object.getPrototypeOf(WrappedSelect)).call(this, { element: element, classNames: classNames }));
+ }
+
+ _createClass(WrappedSelect, [{
+ key: 'appendDocFragment',
+ value: function appendDocFragment(fragment) {
+ this.element.innerHTML = '';
+ this.element.appendChild(fragment);
+ }
+ }, {
+ key: 'placeholderOption',
+ get: function get() {
+ return this.element.querySelector('option[placeholder]');
+ }
+ }, {
+ key: 'optionGroups',
+ get: function get() {
+ return Array.from(this.element.getElementsByTagName('OPTGROUP'));
+ }
+ }, {
+ key: 'options',
+ get: function get() {
+ return Array.from(this.element.options);
+ },
+ set: function set(options) {
+ var fragment = document.createDocumentFragment();
+ var addOptionToFragment = function addOptionToFragment(data) {
+ // Create a standard select option
+ var template = _templates2.default.option(data);
+ // Append it to fragment
+ fragment.appendChild(template);
+ };
+
+ // Add each list item to list
+ options.forEach(function (optionData) {
+ return addOptionToFragment(optionData);
+ });
+
+ this.appendDocFragment(fragment);
+ }
+ }]);
+
+ return WrappedSelect;
+}(_wrappedElement2.default);
+
+exports.default = WrappedSelect;
+
+/***/ }),
+/* 80 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
+ Copyright (c) 2016 Jed Watson.
+ Licensed under the MIT License (MIT), see
+ http://jedwatson.github.io/classnames
+*/
+/* global define */
+
+(function () {
+ 'use strict';
+
+ var hasOwn = {}.hasOwnProperty;
+
+ function classNames () {
+ var classes = [];
+
+ for (var i = 0; i < arguments.length; i++) {
+ var arg = arguments[i];
+ if (!arg) continue;
+
+ var argType = typeof arg;
+
+ if (argType === 'string' || argType === 'number') {
+ classes.push(arg);
+ } else if (Array.isArray(arg)) {
+ classes.push(classNames.apply(null, arg));
+ } else if (argType === 'object') {
+ for (var key in arg) {
+ if (hasOwn.call(arg, key) && arg[key]) {
+ classes.push(key);
+ }
+ }
+ }
+ }
+
+ return classes.join(' ');
+ }
+
+ if (typeof module !== 'undefined' && module.exports) {
+ module.exports = classNames;
+ } else if (true) {
+ // register as 'classnames', consistent with npm package name
+ !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
+ return classNames;
+ }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
+ __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+ } else {
+ window.classNames = classNames;
+ }
+}());
+
+
+/***/ }),
+/* 81 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.clearChoices = exports.activateChoices = exports.filterChoices = exports.addChoice = undefined;
+
+var _constants = __webpack_require__(9);
+
+var addChoice = exports.addChoice = function addChoice(value, label, id, groupId, disabled, elementId, customProperties, placeholder, keyCode) {
+ return {
+ type: _constants.ACTION_TYPES.ADD_CHOICE,
+ value: value,
+ label: label,
+ id: id,
+ groupId: groupId,
+ disabled: disabled,
+ elementId: elementId,
+ customProperties: customProperties,
+ placeholder: placeholder,
+ keyCode: keyCode
+ };
+};
+
+var filterChoices = exports.filterChoices = function filterChoices(results) {
+ return {
+ type: _constants.ACTION_TYPES.FILTER_CHOICES,
+ results: results
+ };
+};
+
+var activateChoices = exports.activateChoices = function activateChoices() {
+ var active = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+ return {
+ type: _constants.ACTION_TYPES.ACTIVATE_CHOICES,
+ active: active
+ };
+};
+
+var clearChoices = exports.clearChoices = function clearChoices() {
+ return {
+ type: _constants.ACTION_TYPES.CLEAR_CHOICES
+ };
+};
+
+/***/ }),
+/* 82 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.highlightItem = exports.removeItem = exports.addItem = undefined;
+
+var _constants = __webpack_require__(9);
+
+var addItem = exports.addItem = function addItem(value, label, id, choiceId, groupId, customProperties, placeholder, keyCode) {
+ return {
+ type: _constants.ACTION_TYPES.ADD_ITEM,
+ value: value,
+ label: label,
+ id: id,
+ choiceId: choiceId,
+ groupId: groupId,
+ customProperties: customProperties,
+ placeholder: placeholder,
+ keyCode: keyCode
+ };
+};
+
+var removeItem = exports.removeItem = function removeItem(id, choiceId) {
+ return {
+ type: _constants.ACTION_TYPES.REMOVE_ITEM,
+ id: id,
+ choiceId: choiceId
+ };
+};
+
+var highlightItem = exports.highlightItem = function highlightItem(id, highlighted) {
+ return {
+ type: _constants.ACTION_TYPES.HIGHLIGHT_ITEM,
+ id: id,
+ highlighted: highlighted
+ };
+};
+
+/***/ }),
+/* 83 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+exports.addGroup = undefined;
+
+var _constants = __webpack_require__(9);
+
+/* eslint-disable import/prefer-default-export */
+var addGroup = exports.addGroup = function addGroup(value, id, active, disabled) {
+ return {
+ type: _constants.ACTION_TYPES.ADD_GROUP,
+ value: value,
+ id: id,
+ active: active,
+ disabled: disabled
+ };
+};
+
+/***/ }),
+/* 84 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", {
+ value: true
+});
+/* eslint-disable import/prefer-default-export */
+var clearAll = exports.clearAll = function clearAll() {
+ return {
+ type: 'CLEAR_ALL'
+ };
+};
+
+/***/ })
+/******/ ]);
+});
+//# sourceMappingURL=choices.js.map
\ No newline at end of file
diff --git a/public/assets/scripts/choices.js.map b/public/assets/scripts/choices.js.map
new file mode 100644
index 0000000..b4f2c9f
--- /dev/null
+++ b/public/assets/scripts/choices.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"choices.js","sources":["webpack:///webpack/universalModuleDefinition","webpack:///webpack/bootstrap 436f8b54baae1fb8bee0","webpack:///./node_modules/core-js/modules/_wks.js","webpack:///src/scripts/src/lib/utils.js","webpack:///./node_modules/core-js/modules/_global.js","webpack:///./node_modules/core-js/modules/_core.js","webpack:///./node_modules/core-js/modules/_hide.js","webpack:///./node_modules/core-js/modules/_object-dp.js","webpack:///./node_modules/core-js/modules/_an-object.js","webpack:///./node_modules/core-js/modules/_descriptors.js","webpack:///./node_modules/core-js/modules/_has.js","webpack:///src/scripts/src/constants.js","webpack:///./node_modules/core-js/modules/_to-integer.js","webpack:///./node_modules/core-js/modules/_defined.js","webpack:///./node_modules/core-js/modules/_is-object.js","webpack:///./node_modules/core-js/modules/_property-desc.js","webpack:///./node_modules/core-js/modules/_uid.js","webpack:///./node_modules/core-js/modules/_iterators.js","webpack:///./node_modules/core-js/modules/_shared-key.js","webpack:///./node_modules/core-js/modules/_library.js","webpack:///./node_modules/core-js/modules/_export.js","webpack:///./node_modules/core-js/modules/_fails.js","webpack:///./node_modules/core-js/modules/_dom-create.js","webpack:///./node_modules/core-js/modules/_redefine.js","webpack:///./node_modules/core-js/modules/_ctx.js","webpack:///./node_modules/core-js/modules/_to-iobject.js","webpack:///./node_modules/core-js/modules/_cof.js","webpack:///./node_modules/core-js/modules/_to-length.js","webpack:///./node_modules/core-js/modules/_shared.js","webpack:///./node_modules/core-js/modules/_enum-bug-keys.js","webpack:///./node_modules/core-js/modules/_set-to-string-tag.js","webpack:///./node_modules/core-js/modules/_to-object.js","webpack:///./node_modules/lodash-es/_root.js","webpack:///./node_modules/lodash-es/_Symbol.js","webpack:///./node_modules/lodash-es/_getRawTag.js","webpack:///./node_modules/lodash-es/_objectToString.js","webpack:///./node_modules/lodash-es/_baseGetTag.js","webpack:///./node_modules/lodash-es/_overArg.js","webpack:///./node_modules/lodash-es/_getPrototype.js","webpack:///./node_modules/lodash-es/isObjectLike.js","webpack:///./node_modules/lodash-es/isPlainObject.js","webpack:///./node_modules/redux/es/createStore.js","webpack:///./node_modules/redux/es/utils/warning.js","webpack:///./node_modules/redux/es/combineReducers.js","webpack:///./node_modules/redux/es/bindActionCreators.js","webpack:///./node_modules/redux/es/compose.js","webpack:///./node_modules/redux/es/applyMiddleware.js","webpack:///./node_modules/redux/es/index.js","webpack:///(webpack)/buildin/global.js","webpack:///src/scripts/src/components/wrapped-element.js","webpack:///src/scripts/src/templates.js","webpack:///src/scripts/src/choices.js","webpack:///./node_modules/fuse.js/dist/fuse.js","webpack:///src/scripts/src/lib/polyfills.js","webpack:///./node_modules/core-js/fn/array/from.js","webpack:///./node_modules/core-js/modules/es6.string.iterator.js","webpack:///./node_modules/core-js/modules/_string-at.js","webpack:///./node_modules/core-js/modules/_iter-define.js","webpack:///./node_modules/core-js/modules/_ie8-dom-define.js","webpack:///./node_modules/core-js/modules/_to-primitive.js","webpack:///./node_modules/core-js/modules/_a-function.js","webpack:///./node_modules/core-js/modules/_iter-create.js","webpack:///./node_modules/core-js/modules/_object-create.js","webpack:///./node_modules/core-js/modules/_object-dps.js","webpack:///./node_modules/core-js/modules/_object-keys.js","webpack:///./node_modules/core-js/modules/_object-keys-internal.js","webpack:///./node_modules/core-js/modules/_iobject.js","webpack:///./node_modules/core-js/modules/_array-includes.js","webpack:///./node_modules/core-js/modules/_to-absolute-index.js","webpack:///./node_modules/core-js/modules/_html.js","webpack:///./node_modules/core-js/modules/_object-gpo.js","webpack:///./node_modules/core-js/modules/es6.array.from.js","webpack:///./node_modules/core-js/modules/_iter-call.js","webpack:///./node_modules/core-js/modules/_is-array-iter.js","webpack:///./node_modules/core-js/modules/_create-property.js","webpack:///./node_modules/core-js/modules/core.get-iterator-method.js","webpack:///./node_modules/core-js/modules/_classof.js","webpack:///./node_modules/core-js/modules/_iter-detect.js","webpack:///./node_modules/custom-event-polyfill/custom-event-polyfill.js","webpack:///src/scripts/src/store/store.js","webpack:///./node_modules/lodash-es/_freeGlobal.js","webpack:///./node_modules/symbol-observable/index.js","webpack:///./node_modules/symbol-observable/lib/index.js","webpack:///(webpack)/buildin/module.js","webpack:///./node_modules/symbol-observable/lib/ponyfill.js","webpack:///src/scripts/src/reducers/index.js","webpack:///src/scripts/src/reducers/items.js","webpack:///src/scripts/src/reducers/groups.js","webpack:///src/scripts/src/reducers/choices.js","webpack:///src/scripts/src/components/index.js","webpack:///src/scripts/src/components/dropdown.js","webpack:///src/scripts/src/components/container.js","webpack:///src/scripts/src/components/input.js","webpack:///src/scripts/src/components/list.js","webpack:///src/scripts/src/components/wrapped-input.js","webpack:///src/scripts/src/components/wrapped-select.js","webpack:///./node_modules/classnames/index.js","webpack:///src/scripts/src/actions/choices.js","webpack:///src/scripts/src/actions/items.js","webpack:///src/scripts/src/actions/groups.js","webpack:///src/scripts/src/actions/misc.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n //CommonJS2\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n //AMD\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n //CommonJS\n\telse if(typeof exports === 'object')\n\t\texports[\"Choices\"] = factory();\n //Window\n\telse\n\t\troot[\"Choices\"] = factory();\n})(typeof self !== 'undefined' ? self : this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/public/assets/scripts/\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 34);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 436f8b54baae1fb8bee0","var store = require('./_shared')('wks');\nvar uid = require('./_uid');\nvar Symbol = require('./_global').Symbol;\nvar USE_SYMBOL = typeof Symbol == 'function';\n\nvar $exports = module.exports = function (name) {\n return store[name] || (store[name] =\n USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n$exports.store = store;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_wks.js\n// module id = 0\n// module chunks = 0","/* eslint-disable */\n\n/**\n * Generates a string of random chars\n * @param {Number} length Length of the string to generate\n * @return {String} String of random chars\n */\nexport const generateChars = function(length) {\n let chars = '';\n\n for (let i = 0; i < length; i++) {\n const randomChar = getRandomNumber(0, 36);\n chars += randomChar.toString(36);\n }\n\n return chars;\n};\n\n/**\n * Generates a unique id based on an element\n * @param {HTMLElement} element Element to generate the id from\n * @param {String} Prefix for the Id\n * @return {String} Unique Id\n */\nexport const generateId = function(element, prefix) {\n let id = element.id || (element.name && (`${element.name}-${generateChars(2)}`)) || generateChars(4);\n id = id.replace(/(:|\\.|\\[|\\]|,)/g, '');\n id = prefix + id;\n\n return id;\n};\n\n/**\n * Tests the type of an object\n * @param {String} type Type to test object against\n * @param {Object} obj Object to be tested\n * @return {Boolean}\n */\nexport const getType = function(obj) {\n return Object.prototype.toString.call(obj).slice(8, -1);\n};\n\n/**\n * Tests the type of an object\n * @param {String} type Type to test object against\n * @param {Object} obj Object to be tested\n * @return {Boolean}\n */\nexport const isType = function(type, obj) {\n const clas = getType(obj);\n return obj !== undefined && obj !== null && clas === type;\n};\n\n/**\n * Tests to see if a passed object is an element\n * @param {Object} obj Object to be tested\n * @return {Boolean}\n */\nexport const isElement = o => (\n typeof HTMLElement === 'object' ? o instanceof HTMLElement : // DOM2\n o && typeof o === 'object' && o !== null && o.nodeType === 1 && typeof o.nodeName === 'string'\n);\n\n/**\n * Merges unspecified amount of objects into new object\n * @private\n * @return {Object} Merged object of arguments\n */\nexport const extend = function() {\n const extended = {};\n const length = arguments.length;\n\n /**\n * Merge one object into another\n * @param {Object} obj Object to merge into extended object\n */\n const merge = function(obj) {\n for (const prop in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, prop)) {\n // If deep merge and property is an object, merge properties\n if (isType('Object', obj[prop])) {\n extended[prop] = extend(true, extended[prop], obj[prop]);\n } else {\n extended[prop] = obj[prop];\n }\n }\n }\n };\n\n // Loop through each passed argument\n for (let i = 0; i < length; i++) {\n // store argument at position i\n const obj = arguments[i];\n\n // If we are in fact dealing with an object, merge it.\n if (isType('Object', obj)) {\n merge(obj);\n }\n }\n\n return extended;\n};\n\nexport const wrap = function(element, wrapper) {\n wrapper = wrapper || document.createElement('div');\n if (element.nextSibling) {\n element.parentNode.insertBefore(wrapper, element.nextSibling);\n } else {\n element.parentNode.appendChild(wrapper);\n }\n return wrapper.appendChild(element);\n};\n\n/**\n * Find ancestor in DOM tree\n * @param {NodeElement} el Element to start search from\n * @param {[type]} cls Class of parent\n * @return {NodeElement} Found parent element\n */\nexport const findAncestor = function(el, cls) {\n while ((el = el.parentElement) && !el.classList.contains(cls));\n return el;\n};\n\n/**\n * Find ancestor in DOM tree by attribute name\n * @param {NodeElement} el Element to start search from\n * @param {string} attr Attribute name of parent\n * @return {?NodeElement} Found parent element or null\n */\nexport const findAncestorByAttrName = function(el, attr) {\n let target = el;\n\n while (target) {\n if (target.hasAttribute(attr)) {\n return target;\n }\n\n target = target.parentElement;\n }\n\n return null;\n};\n\n/**\n * Get the next or previous element from a given start point\n * @param {HTMLElement} startEl Element to start position from\n * @param {String} className The class we will look through\n * @param {Number} direction Positive next element, negative previous element\n * @return {[HTMLElement} Found element\n */\nexport const getAdjacentEl = (startEl, className, direction = 1) => {\n if (!startEl || !className) return;\n\n const parent = startEl.parentNode.parentNode;\n const children = Array.from(parent.querySelectorAll(className));\n\n const startPos = children.indexOf(startEl);\n const operatorDirection = direction > 0 ? 1 : -1;\n\n return children[startPos + operatorDirection];\n};\n\n/**\n * Determine whether an element is within\n * @param {HTMLElement} el Element to test\n * @param {HTMLElement} parent Scrolling parent\n * @param {Number} direction Whether element is visible from above or below\n * @return {Boolean}\n */\nexport const isScrolledIntoView = (el, parent, direction = 1) => {\n if (!el) return;\n\n let isVisible;\n\n if (direction > 0) {\n // In view from bottom\n isVisible = (parent.scrollTop + parent.offsetHeight) >= (el.offsetTop + el.offsetHeight);\n } else {\n // In view from top\n isVisible = el.offsetTop >= parent.scrollTop;\n }\n\n return isVisible;\n};\n\n/**\n * Escape html in the string\n * @param {String} html Initial string/html\n * @return {String} Sanitised string\n */\nexport const stripHTML = html =>\n html.replace(/&/g, '&')\n .replace(/>/g, '&rt;')\n .replace(/ {\n const value = input.value || input.placeholder;\n let width = input.offsetWidth;\n\n if (value) {\n const testEl = strToEl(`${stripHTML(value)}`);\n testEl.style.position = 'absolute';\n testEl.style.padding = '0';\n testEl.style.top = '-9999px';\n testEl.style.left = '-9999px';\n testEl.style.width = 'auto';\n testEl.style.whiteSpace = 'pre';\n\n if (document.body.contains(input) && window.getComputedStyle) {\n const inputStyle = window.getComputedStyle(input);\n\n if (inputStyle) {\n testEl.style.fontSize = inputStyle.fontSize;\n testEl.style.fontFamily = inputStyle.fontFamily;\n testEl.style.fontWeight = inputStyle.fontWeight;\n testEl.style.fontStyle = inputStyle.fontStyle;\n testEl.style.letterSpacing = inputStyle.letterSpacing;\n testEl.style.textTransform = inputStyle.textTransform;\n testEl.style.padding = inputStyle.padding;\n }\n }\n\n document.body.appendChild(testEl);\n\n if (value && testEl.offsetWidth !== input.offsetWidth) {\n width = testEl.offsetWidth + 4;\n }\n\n document.body.removeChild(testEl);\n }\n\n return `${width}px`;\n};\n\n/**\n * Sorting function for current and previous string\n * @param {String} a Current value\n * @param {String} b Next value\n * @return {Number} -1 for after previous,\n * 1 for before,\n * 0 for same location\n */\nexport const sortByAlpha = (a, b) => {\n const labelA = (a.label || a.value).toLowerCase();\n const labelB = (b.label || b.value).toLowerCase();\n\n if (labelA < labelB) return -1;\n if (labelA > labelB) return 1;\n return 0;\n};\n\n/**\n * Sort by numeric score\n * @param {Object} a Current value\n * @param {Object} b Next value\n * @return {Number} -1 for after previous,\n * 1 for before,\n * 0 for same location\n */\nexport const sortByScore = (a, b) => a.score - b.score;\n\n/**\n * Dispatch native event\n * @param {NodeElement} element Element to trigger event on\n * @param {String} type Type of event to trigger\n * @param {Object} customArgs Data to pass with event\n * @return {Object} Triggered event\n */\nexport const dispatchEvent = (element, type, customArgs = null) => {\n const event = new CustomEvent(type, {\n detail: customArgs,\n bubbles: true,\n cancelable: true,\n });\n\n return element.dispatchEvent(event);\n};\n\n/**\n * Tests value against a regular expression\n * @param {string} value Value to test\n * @return {Boolean} Whether test passed/failed\n * @private\n */\nexport const regexFilter = (value, regex) => {\n if (!value || !regex) {\n return false;\n }\n\n const expression = new RegExp(regex.source, 'i');\n return expression.test(value);\n};\n\nexport const getWindowHeight = () => {\n const body = document.body;\n const html = document.documentElement;\n return Math.max(\n body.scrollHeight,\n body.offsetHeight,\n html.clientHeight,\n html.scrollHeight,\n html.offsetHeight,\n );\n};\n\nexport const reduceToValues = (items, key = 'value') => {\n const values = items.reduce((prev, current) => {\n prev.push(current[key]);\n return prev;\n }, []);\n\n return values;\n}\n\nexport const isIE11 = () => {\n return !!(navigator.userAgent.match(/Trident/) && navigator.userAgent.match(/rv[ :]11/));\n};\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/lib/utils.js","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n ? window : typeof self != 'undefined' && self.Math == Math ? self\n // eslint-disable-next-line no-new-func\n : Function('return this')();\nif (typeof __g == 'number') __g = global; // eslint-disable-line no-undef\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_global.js\n// module id = 2\n// module chunks = 0","var core = module.exports = { version: '2.5.6' };\nif (typeof __e == 'number') __e = core; // eslint-disable-line no-undef\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_core.js\n// module id = 3\n// module chunks = 0","var dP = require('./_object-dp');\nvar createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function (object, key, value) {\n return dP.f(object, key, createDesc(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_hide.js\n// module id = 4\n// module chunks = 0","var anObject = require('./_an-object');\nvar IE8_DOM_DEFINE = require('./_ie8-dom-define');\nvar toPrimitive = require('./_to-primitive');\nvar dP = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPrimitive(P, true);\n anObject(Attributes);\n if (IE8_DOM_DEFINE) try {\n return dP(O, P, Attributes);\n } catch (e) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_object-dp.js\n// module id = 5\n// module chunks = 0","var isObject = require('./_is-object');\nmodule.exports = function (it) {\n if (!isObject(it)) throw TypeError(it + ' is not an object!');\n return it;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_an-object.js\n// module id = 6\n// module chunks = 0","// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function () {\n return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_descriptors.js\n// module id = 7\n// module chunks = 0","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function (it, key) {\n return hasOwnProperty.call(it, key);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_has.js\n// module id = 8\n// module chunks = 0","import { stripHTML } from './lib/utils';\n\nexport const DEFAULT_CLASSNAMES = {\n containerOuter: 'choices',\n containerInner: 'choices__inner',\n input: 'choices__input',\n inputCloned: 'choices__input--cloned',\n list: 'choices__list',\n listItems: 'choices__list--multiple',\n listSingle: 'choices__list--single',\n listDropdown: 'choices__list--dropdown',\n item: 'choices__item',\n itemSelectable: 'choices__item--selectable',\n itemDisabled: 'choices__item--disabled',\n itemChoice: 'choices__item--choice',\n placeholder: 'choices__placeholder',\n group: 'choices__group',\n groupHeading: 'choices__heading',\n button: 'choices__button',\n activeState: 'is-active',\n focusState: 'is-focused',\n openState: 'is-open',\n disabledState: 'is-disabled',\n highlightedState: 'is-highlighted',\n hiddenState: 'is-hidden',\n flippedState: 'is-flipped',\n loadingState: 'is-loading',\n noResults: 'has-no-results',\n noChoices: 'has-no-choices',\n};\n\nexport const DEFAULT_CONFIG = {\n items: [],\n choices: [],\n silent: false,\n renderChoiceLimit: -1,\n maxItemCount: -1,\n addItems: true,\n removeItems: true,\n removeItemButton: false,\n editItems: false,\n duplicateItems: true,\n delimiter: ',',\n paste: true,\n searchEnabled: true,\n searchChoices: true,\n searchFloor: 1,\n searchResultLimit: 4,\n searchFields: ['label', 'value'],\n position: 'auto',\n resetScrollPosition: true,\n regexFilter: null,\n shouldSort: true,\n shouldSortItems: false,\n placeholder: true,\n placeholderValue: null,\n searchPlaceholderValue: null,\n prependValue: null,\n appendValue: null,\n renderSelectedChoices: 'auto',\n loadingText: 'Loading...',\n noResultsText: 'No results found',\n noChoicesText: 'No choices to choose from',\n itemSelectText: 'Press to select',\n uniqueItemText: 'Only unique values can be added.',\n addItemText: value => `Press Enter to add \"${stripHTML(value)}\"`,\n maxItemText: maxItemCount => `Only ${maxItemCount} values can be added.`,\n itemComparer: (choice, item) => (choice === item),\n fuseOptions: {\n includeScore: true,\n },\n callbackOnInit: null,\n callbackOnCreateTemplates: null,\n};\n\nexport const EVENTS = {\n showDropdown: 'showDropdown',\n hideDropdown: 'hideDropdown',\n change: 'change',\n choice: 'choice',\n search: 'search',\n addItem: 'addItem',\n removeItem: 'removeItem',\n highlightItem: 'highlightItem',\n};\n\nexport const ACTION_TYPES = {\n ADD_CHOICE: 'ADD_CHOICE',\n FILTER_CHOICES: 'FILTER_CHOICES',\n ACTIVATE_CHOICES: 'ACTIVATE_CHOICES',\n CLEAR_CHOICES: 'CLEAR_CHOICES',\n ADD_GROUP: 'ADD_GROUP',\n ADD_ITEM: 'ADD_ITEM',\n REMOVE_ITEM: 'REMOVE_ITEM',\n HIGHLIGHT_ITEM: 'HIGHLIGHT_ITEM',\n CLEAR_ALL: 'CLEAR_ALL',\n};\n\nexport const KEY_CODES = {\n BACK_KEY: 46,\n DELETE_KEY: 8,\n ENTER_KEY: 13,\n A_KEY: 65,\n ESC_KEY: 27,\n UP_KEY: 38,\n DOWN_KEY: 40,\n PAGE_UP_KEY: 33,\n PAGE_DOWN_KEY: 34,\n};\n\nexport const SCROLLING_SPEED = 4;\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/constants.js","// 7.1.4 ToInteger\nvar ceil = Math.ceil;\nvar floor = Math.floor;\nmodule.exports = function (it) {\n return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_to-integer.js\n// module id = 10\n// module chunks = 0","// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function (it) {\n if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n return it;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_defined.js\n// module id = 11\n// module chunks = 0","module.exports = function (it) {\n return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_is-object.js\n// module id = 12\n// module chunks = 0","module.exports = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_property-desc.js\n// module id = 13\n// module chunks = 0","var id = 0;\nvar px = Math.random();\nmodule.exports = function (key) {\n return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_uid.js\n// module id = 14\n// module chunks = 0","module.exports = {};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_iterators.js\n// module id = 15\n// module chunks = 0","var shared = require('./_shared')('keys');\nvar uid = require('./_uid');\nmodule.exports = function (key) {\n return shared[key] || (shared[key] = uid(key));\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_shared-key.js\n// module id = 16\n// module chunks = 0","module.exports = false;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_library.js\n// module id = 17\n// module chunks = 0","var global = require('./_global');\nvar core = require('./_core');\nvar hide = require('./_hide');\nvar redefine = require('./_redefine');\nvar ctx = require('./_ctx');\nvar PROTOTYPE = 'prototype';\n\nvar $export = function (type, name, source) {\n var IS_FORCED = type & $export.F;\n var IS_GLOBAL = type & $export.G;\n var IS_STATIC = type & $export.S;\n var IS_PROTO = type & $export.P;\n var IS_BIND = type & $export.B;\n var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE];\n var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});\n var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});\n var key, own, out, exp;\n if (IS_GLOBAL) source = name;\n for (key in source) {\n // contains in native\n own = !IS_FORCED && target && target[key] !== undefined;\n // export native or passed\n out = (own ? target : source)[key];\n // bind timers to global for call from export context\n exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n // extend global\n if (target) redefine(target, key, out, type & $export.U);\n // export\n if (exports[key] != out) hide(exports, key, exp);\n if (IS_PROTO && expProto[key] != out) expProto[key] = out;\n }\n};\nglobal.core = core;\n// type bitmap\n$export.F = 1; // forced\n$export.G = 2; // global\n$export.S = 4; // static\n$export.P = 8; // proto\n$export.B = 16; // bind\n$export.W = 32; // wrap\n$export.U = 64; // safe\n$export.R = 128; // real proto method for `library`\nmodule.exports = $export;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_export.js\n// module id = 18\n// module chunks = 0","module.exports = function (exec) {\n try {\n return !!exec();\n } catch (e) {\n return true;\n }\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_fails.js\n// module id = 19\n// module chunks = 0","var isObject = require('./_is-object');\nvar document = require('./_global').document;\n// typeof document.createElement is 'object' in old IE\nvar is = isObject(document) && isObject(document.createElement);\nmodule.exports = function (it) {\n return is ? document.createElement(it) : {};\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_dom-create.js\n// module id = 20\n// module chunks = 0","var global = require('./_global');\nvar hide = require('./_hide');\nvar has = require('./_has');\nvar SRC = require('./_uid')('src');\nvar TO_STRING = 'toString';\nvar $toString = Function[TO_STRING];\nvar TPL = ('' + $toString).split(TO_STRING);\n\nrequire('./_core').inspectSource = function (it) {\n return $toString.call(it);\n};\n\n(module.exports = function (O, key, val, safe) {\n var isFunction = typeof val == 'function';\n if (isFunction) has(val, 'name') || hide(val, 'name', key);\n if (O[key] === val) return;\n if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));\n if (O === global) {\n O[key] = val;\n } else if (!safe) {\n delete O[key];\n hide(O, key, val);\n } else if (O[key]) {\n O[key] = val;\n } else {\n hide(O, key, val);\n }\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, TO_STRING, function toString() {\n return typeof this == 'function' && this[SRC] || $toString.call(this);\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_redefine.js\n// module id = 21\n// module chunks = 0","// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function (fn, that, length) {\n aFunction(fn);\n if (that === undefined) return fn;\n switch (length) {\n case 1: return function (a) {\n return fn.call(that, a);\n };\n case 2: return function (a, b) {\n return fn.call(that, a, b);\n };\n case 3: return function (a, b, c) {\n return fn.call(that, a, b, c);\n };\n }\n return function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_ctx.js\n// module id = 22\n// module chunks = 0","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./_iobject');\nvar defined = require('./_defined');\nmodule.exports = function (it) {\n return IObject(defined(it));\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_to-iobject.js\n// module id = 23\n// module chunks = 0","var toString = {}.toString;\n\nmodule.exports = function (it) {\n return toString.call(it).slice(8, -1);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_cof.js\n// module id = 24\n// module chunks = 0","// 7.1.15 ToLength\nvar toInteger = require('./_to-integer');\nvar min = Math.min;\nmodule.exports = function (it) {\n return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_to-length.js\n// module id = 25\n// module chunks = 0","var core = require('./_core');\nvar global = require('./_global');\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || (global[SHARED] = {});\n\n(module.exports = function (key, value) {\n return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n version: core.version,\n mode: require('./_library') ? 'pure' : 'global',\n copyright: '© 2018 Denis Pushkarev (zloirock.ru)'\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_shared.js\n// module id = 26\n// module chunks = 0","// IE 8- don't enum bug keys\nmodule.exports = (\n 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n).split(',');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_enum-bug-keys.js\n// module id = 27\n// module chunks = 0","var def = require('./_object-dp').f;\nvar has = require('./_has');\nvar TAG = require('./_wks')('toStringTag');\n\nmodule.exports = function (it, tag, stat) {\n if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_set-to-string-tag.js\n// module id = 28\n// module chunks = 0","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function (it) {\n return Object(defined(it));\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_to-object.js\n// module id = 29\n// module chunks = 0","import freeGlobal from './_freeGlobal.js';\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nexport default root;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-es/_root.js\n// module id = null\n// module chunks = ","import root from './_root.js';\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nexport default Symbol;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-es/_Symbol.js\n// module id = null\n// module chunks = ","import Symbol from './_Symbol.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n}\n\nexport default getRawTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-es/_getRawTag.js\n// module id = null\n// module chunks = ","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n return nativeObjectToString.call(value);\n}\n\nexport default objectToString;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-es/_objectToString.js\n// module id = null\n// module chunks = ","import Symbol from './_Symbol.js';\nimport getRawTag from './_getRawTag.js';\nimport objectToString from './_objectToString.js';\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n}\n\nexport default baseGetTag;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-es/_baseGetTag.js\n// module id = null\n// module chunks = ","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n}\n\nexport default overArg;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-es/_overArg.js\n// module id = null\n// module chunks = ","import overArg from './_overArg.js';\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nexport default getPrototype;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-es/_getPrototype.js\n// module id = null\n// module chunks = ","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return value != null && typeof value == 'object';\n}\n\nexport default isObjectLike;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-es/isObjectLike.js\n// module id = null\n// module chunks = ","import baseGetTag from './_baseGetTag.js';\nimport getPrototype from './_getPrototype.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n return false;\n }\n var proto = getPrototype(value);\n if (proto === null) {\n return true;\n }\n var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n funcToString.call(Ctor) == objectCtorString;\n}\n\nexport default isPlainObject;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-es/isPlainObject.js\n// module id = null\n// module chunks = ","import isPlainObject from 'lodash-es/isPlainObject';\nimport $$observable from 'symbol-observable';\n\n/**\n * These are private action types reserved by Redux.\n * For any unknown actions, you must return the current state.\n * If the current state is undefined, you must return the initial state.\n * Do not reference these action types directly in your code.\n */\nexport var ActionTypes = {\n INIT: '@@redux/INIT'\n\n /**\n * Creates a Redux store that holds the state tree.\n * The only way to change the data in the store is to call `dispatch()` on it.\n *\n * There should only be a single store in your app. To specify how different\n * parts of the state tree respond to actions, you may combine several reducers\n * into a single reducer function by using `combineReducers`.\n *\n * @param {Function} reducer A function that returns the next state tree, given\n * the current state tree and the action to handle.\n *\n * @param {any} [preloadedState] The initial state. You may optionally specify it\n * to hydrate the state from the server in universal apps, or to restore a\n * previously serialized user session.\n * If you use `combineReducers` to produce the root reducer function, this must be\n * an object with the same shape as `combineReducers` keys.\n *\n * @param {Function} [enhancer] The store enhancer. You may optionally specify it\n * to enhance the store with third-party capabilities such as middleware,\n * time travel, persistence, etc. The only store enhancer that ships with Redux\n * is `applyMiddleware()`.\n *\n * @returns {Store} A Redux store that lets you read the state, dispatch actions\n * and subscribe to changes.\n */\n};export default function createStore(reducer, preloadedState, enhancer) {\n var _ref2;\n\n if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {\n enhancer = preloadedState;\n preloadedState = undefined;\n }\n\n if (typeof enhancer !== 'undefined') {\n if (typeof enhancer !== 'function') {\n throw new Error('Expected the enhancer to be a function.');\n }\n\n return enhancer(createStore)(reducer, preloadedState);\n }\n\n if (typeof reducer !== 'function') {\n throw new Error('Expected the reducer to be a function.');\n }\n\n var currentReducer = reducer;\n var currentState = preloadedState;\n var currentListeners = [];\n var nextListeners = currentListeners;\n var isDispatching = false;\n\n function ensureCanMutateNextListeners() {\n if (nextListeners === currentListeners) {\n nextListeners = currentListeners.slice();\n }\n }\n\n /**\n * Reads the state tree managed by the store.\n *\n * @returns {any} The current state tree of your application.\n */\n function getState() {\n return currentState;\n }\n\n /**\n * Adds a change listener. It will be called any time an action is dispatched,\n * and some part of the state tree may potentially have changed. You may then\n * call `getState()` to read the current state tree inside the callback.\n *\n * You may call `dispatch()` from a change listener, with the following\n * caveats:\n *\n * 1. The subscriptions are snapshotted just before every `dispatch()` call.\n * If you subscribe or unsubscribe while the listeners are being invoked, this\n * will not have any effect on the `dispatch()` that is currently in progress.\n * However, the next `dispatch()` call, whether nested or not, will use a more\n * recent snapshot of the subscription list.\n *\n * 2. The listener should not expect to see all state changes, as the state\n * might have been updated multiple times during a nested `dispatch()` before\n * the listener is called. It is, however, guaranteed that all subscribers\n * registered before the `dispatch()` started will be called with the latest\n * state by the time it exits.\n *\n * @param {Function} listener A callback to be invoked on every dispatch.\n * @returns {Function} A function to remove this change listener.\n */\n function subscribe(listener) {\n if (typeof listener !== 'function') {\n throw new Error('Expected listener to be a function.');\n }\n\n var isSubscribed = true;\n\n ensureCanMutateNextListeners();\n nextListeners.push(listener);\n\n return function unsubscribe() {\n if (!isSubscribed) {\n return;\n }\n\n isSubscribed = false;\n\n ensureCanMutateNextListeners();\n var index = nextListeners.indexOf(listener);\n nextListeners.splice(index, 1);\n };\n }\n\n /**\n * Dispatches an action. It is the only way to trigger a state change.\n *\n * The `reducer` function, used to create the store, will be called with the\n * current state tree and the given `action`. Its return value will\n * be considered the **next** state of the tree, and the change listeners\n * will be notified.\n *\n * The base implementation only supports plain object actions. If you want to\n * dispatch a Promise, an Observable, a thunk, or something else, you need to\n * wrap your store creating function into the corresponding middleware. For\n * example, see the documentation for the `redux-thunk` package. Even the\n * middleware will eventually dispatch plain object actions using this method.\n *\n * @param {Object} action A plain object representing “what changed”. It is\n * a good idea to keep actions serializable so you can record and replay user\n * sessions, or use the time travelling `redux-devtools`. An action must have\n * a `type` property which may not be `undefined`. It is a good idea to use\n * string constants for action types.\n *\n * @returns {Object} For convenience, the same action object you dispatched.\n *\n * Note that, if you use a custom middleware, it may wrap `dispatch()` to\n * return something else (for example, a Promise you can await).\n */\n function dispatch(action) {\n if (!isPlainObject(action)) {\n throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');\n }\n\n if (typeof action.type === 'undefined') {\n throw new Error('Actions may not have an undefined \"type\" property. ' + 'Have you misspelled a constant?');\n }\n\n if (isDispatching) {\n throw new Error('Reducers may not dispatch actions.');\n }\n\n try {\n isDispatching = true;\n currentState = currentReducer(currentState, action);\n } finally {\n isDispatching = false;\n }\n\n var listeners = currentListeners = nextListeners;\n for (var i = 0; i < listeners.length; i++) {\n var listener = listeners[i];\n listener();\n }\n\n return action;\n }\n\n /**\n * Replaces the reducer currently used by the store to calculate the state.\n *\n * You might need this if your app implements code splitting and you want to\n * load some of the reducers dynamically. You might also need this if you\n * implement a hot reloading mechanism for Redux.\n *\n * @param {Function} nextReducer The reducer for the store to use instead.\n * @returns {void}\n */\n function replaceReducer(nextReducer) {\n if (typeof nextReducer !== 'function') {\n throw new Error('Expected the nextReducer to be a function.');\n }\n\n currentReducer = nextReducer;\n dispatch({ type: ActionTypes.INIT });\n }\n\n /**\n * Interoperability point for observable/reactive libraries.\n * @returns {observable} A minimal observable of state changes.\n * For more information, see the observable proposal:\n * https://github.com/tc39/proposal-observable\n */\n function observable() {\n var _ref;\n\n var outerSubscribe = subscribe;\n return _ref = {\n /**\n * The minimal observable subscription method.\n * @param {Object} observer Any object that can be used as an observer.\n * The observer object should have a `next` method.\n * @returns {subscription} An object with an `unsubscribe` method that can\n * be used to unsubscribe the observable from the store, and prevent further\n * emission of values from the observable.\n */\n subscribe: function subscribe(observer) {\n if (typeof observer !== 'object') {\n throw new TypeError('Expected the observer to be an object.');\n }\n\n function observeState() {\n if (observer.next) {\n observer.next(getState());\n }\n }\n\n observeState();\n var unsubscribe = outerSubscribe(observeState);\n return { unsubscribe: unsubscribe };\n }\n }, _ref[$$observable] = function () {\n return this;\n }, _ref;\n }\n\n // When a store is created, an \"INIT\" action is dispatched so that every\n // reducer returns their initial state. This effectively populates\n // the initial state tree.\n dispatch({ type: ActionTypes.INIT });\n\n return _ref2 = {\n dispatch: dispatch,\n subscribe: subscribe,\n getState: getState,\n replaceReducer: replaceReducer\n }, _ref2[$$observable] = observable, _ref2;\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/redux/es/createStore.js\n// module id = null\n// module chunks = ","/**\n * Prints a warning in the console if it exists.\n *\n * @param {String} message The warning message.\n * @returns {void}\n */\nexport default function warning(message) {\n /* eslint-disable no-console */\n if (typeof console !== 'undefined' && typeof console.error === 'function') {\n console.error(message);\n }\n /* eslint-enable no-console */\n try {\n // This error was thrown as a convenience so that if you enable\n // \"break on all exceptions\" in your console,\n // it would pause the execution at this line.\n throw new Error(message);\n /* eslint-disable no-empty */\n } catch (e) {}\n /* eslint-enable no-empty */\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/redux/es/utils/warning.js\n// module id = null\n// module chunks = ","import { ActionTypes } from './createStore';\nimport isPlainObject from 'lodash-es/isPlainObject';\nimport warning from './utils/warning';\n\nfunction getUndefinedStateErrorMessage(key, action) {\n var actionType = action && action.type;\n var actionName = actionType && '\"' + actionType.toString() + '\"' || 'an action';\n\n return 'Given action ' + actionName + ', reducer \"' + key + '\" returned undefined. ' + 'To ignore an action, you must explicitly return the previous state. ' + 'If you want this reducer to hold no value, you can return null instead of undefined.';\n}\n\nfunction getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {\n var reducerKeys = Object.keys(reducers);\n var argumentName = action && action.type === ActionTypes.INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer';\n\n if (reducerKeys.length === 0) {\n return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.';\n }\n\n if (!isPlainObject(inputState)) {\n return 'The ' + argumentName + ' has unexpected type of \"' + {}.toString.call(inputState).match(/\\s([a-z|A-Z]+)/)[1] + '\". Expected argument to be an object with the following ' + ('keys: \"' + reducerKeys.join('\", \"') + '\"');\n }\n\n var unexpectedKeys = Object.keys(inputState).filter(function (key) {\n return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key];\n });\n\n unexpectedKeys.forEach(function (key) {\n unexpectedKeyCache[key] = true;\n });\n\n if (unexpectedKeys.length > 0) {\n return 'Unexpected ' + (unexpectedKeys.length > 1 ? 'keys' : 'key') + ' ' + ('\"' + unexpectedKeys.join('\", \"') + '\" found in ' + argumentName + '. ') + 'Expected to find one of the known reducer keys instead: ' + ('\"' + reducerKeys.join('\", \"') + '\". Unexpected keys will be ignored.');\n }\n}\n\nfunction assertReducerShape(reducers) {\n Object.keys(reducers).forEach(function (key) {\n var reducer = reducers[key];\n var initialState = reducer(undefined, { type: ActionTypes.INIT });\n\n if (typeof initialState === 'undefined') {\n throw new Error('Reducer \"' + key + '\" returned undefined during initialization. ' + 'If the state passed to the reducer is undefined, you must ' + 'explicitly return the initial state. The initial state may ' + 'not be undefined. If you don\\'t want to set a value for this reducer, ' + 'you can use null instead of undefined.');\n }\n\n var type = '@@redux/PROBE_UNKNOWN_ACTION_' + Math.random().toString(36).substring(7).split('').join('.');\n if (typeof reducer(undefined, { type: type }) === 'undefined') {\n throw new Error('Reducer \"' + key + '\" returned undefined when probed with a random type. ' + ('Don\\'t try to handle ' + ActionTypes.INIT + ' or other actions in \"redux/*\" ') + 'namespace. They are considered private. Instead, you must return the ' + 'current state for any unknown actions, unless it is undefined, ' + 'in which case you must return the initial state, regardless of the ' + 'action type. The initial state may not be undefined, but can be null.');\n }\n });\n}\n\n/**\n * Turns an object whose values are different reducer functions, into a single\n * reducer function. It will call every child reducer, and gather their results\n * into a single state object, whose keys correspond to the keys of the passed\n * reducer functions.\n *\n * @param {Object} reducers An object whose values correspond to different\n * reducer functions that need to be combined into one. One handy way to obtain\n * it is to use ES6 `import * as reducers` syntax. The reducers may never return\n * undefined for any action. Instead, they should return their initial state\n * if the state passed to them was undefined, and the current state for any\n * unrecognized action.\n *\n * @returns {Function} A reducer function that invokes every reducer inside the\n * passed object, and builds a state object with the same shape.\n */\nexport default function combineReducers(reducers) {\n var reducerKeys = Object.keys(reducers);\n var finalReducers = {};\n for (var i = 0; i < reducerKeys.length; i++) {\n var key = reducerKeys[i];\n\n if (process.env.NODE_ENV !== 'production') {\n if (typeof reducers[key] === 'undefined') {\n warning('No reducer provided for key \"' + key + '\"');\n }\n }\n\n if (typeof reducers[key] === 'function') {\n finalReducers[key] = reducers[key];\n }\n }\n var finalReducerKeys = Object.keys(finalReducers);\n\n var unexpectedKeyCache = void 0;\n if (process.env.NODE_ENV !== 'production') {\n unexpectedKeyCache = {};\n }\n\n var shapeAssertionError = void 0;\n try {\n assertReducerShape(finalReducers);\n } catch (e) {\n shapeAssertionError = e;\n }\n\n return function combination() {\n var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n var action = arguments[1];\n\n if (shapeAssertionError) {\n throw shapeAssertionError;\n }\n\n if (process.env.NODE_ENV !== 'production') {\n var warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache);\n if (warningMessage) {\n warning(warningMessage);\n }\n }\n\n var hasChanged = false;\n var nextState = {};\n for (var _i = 0; _i < finalReducerKeys.length; _i++) {\n var _key = finalReducerKeys[_i];\n var reducer = finalReducers[_key];\n var previousStateForKey = state[_key];\n var nextStateForKey = reducer(previousStateForKey, action);\n if (typeof nextStateForKey === 'undefined') {\n var errorMessage = getUndefinedStateErrorMessage(_key, action);\n throw new Error(errorMessage);\n }\n nextState[_key] = nextStateForKey;\n hasChanged = hasChanged || nextStateForKey !== previousStateForKey;\n }\n return hasChanged ? nextState : state;\n };\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/redux/es/combineReducers.js\n// module id = null\n// module chunks = ","function bindActionCreator(actionCreator, dispatch) {\n return function () {\n return dispatch(actionCreator.apply(undefined, arguments));\n };\n}\n\n/**\n * Turns an object whose values are action creators, into an object with the\n * same keys, but with every function wrapped into a `dispatch` call so they\n * may be invoked directly. This is just a convenience method, as you can call\n * `store.dispatch(MyActionCreators.doSomething())` yourself just fine.\n *\n * For convenience, you can also pass a single function as the first argument,\n * and get a function in return.\n *\n * @param {Function|Object} actionCreators An object whose values are action\n * creator functions. One handy way to obtain it is to use ES6 `import * as`\n * syntax. You may also pass a single function.\n *\n * @param {Function} dispatch The `dispatch` function available on your Redux\n * store.\n *\n * @returns {Function|Object} The object mimicking the original object, but with\n * every action creator wrapped into the `dispatch` call. If you passed a\n * function as `actionCreators`, the return value will also be a single\n * function.\n */\nexport default function bindActionCreators(actionCreators, dispatch) {\n if (typeof actionCreators === 'function') {\n return bindActionCreator(actionCreators, dispatch);\n }\n\n if (typeof actionCreators !== 'object' || actionCreators === null) {\n throw new Error('bindActionCreators expected an object or a function, instead received ' + (actionCreators === null ? 'null' : typeof actionCreators) + '. ' + 'Did you write \"import ActionCreators from\" instead of \"import * as ActionCreators from\"?');\n }\n\n var keys = Object.keys(actionCreators);\n var boundActionCreators = {};\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n var actionCreator = actionCreators[key];\n if (typeof actionCreator === 'function') {\n boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);\n }\n }\n return boundActionCreators;\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/redux/es/bindActionCreators.js\n// module id = null\n// module chunks = ","/**\n * Composes single-argument functions from right to left. The rightmost\n * function can take multiple arguments as it provides the signature for\n * the resulting composite function.\n *\n * @param {...Function} funcs The functions to compose.\n * @returns {Function} A function obtained by composing the argument functions\n * from right to left. For example, compose(f, g, h) is identical to doing\n * (...args) => f(g(h(...args))).\n */\n\nexport default function compose() {\n for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {\n funcs[_key] = arguments[_key];\n }\n\n if (funcs.length === 0) {\n return function (arg) {\n return arg;\n };\n }\n\n if (funcs.length === 1) {\n return funcs[0];\n }\n\n return funcs.reduce(function (a, b) {\n return function () {\n return a(b.apply(undefined, arguments));\n };\n });\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/redux/es/compose.js\n// module id = null\n// module chunks = ","var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nimport compose from './compose';\n\n/**\n * Creates a store enhancer that applies middleware to the dispatch method\n * of the Redux store. This is handy for a variety of tasks, such as expressing\n * asynchronous actions in a concise manner, or logging every action payload.\n *\n * See `redux-thunk` package as an example of the Redux middleware.\n *\n * Because middleware is potentially asynchronous, this should be the first\n * store enhancer in the composition chain.\n *\n * Note that each middleware will be given the `dispatch` and `getState` functions\n * as named arguments.\n *\n * @param {...Function} middlewares The middleware chain to be applied.\n * @returns {Function} A store enhancer applying the middleware.\n */\nexport default function applyMiddleware() {\n for (var _len = arguments.length, middlewares = Array(_len), _key = 0; _key < _len; _key++) {\n middlewares[_key] = arguments[_key];\n }\n\n return function (createStore) {\n return function (reducer, preloadedState, enhancer) {\n var store = createStore(reducer, preloadedState, enhancer);\n var _dispatch = store.dispatch;\n var chain = [];\n\n var middlewareAPI = {\n getState: store.getState,\n dispatch: function dispatch(action) {\n return _dispatch(action);\n }\n };\n chain = middlewares.map(function (middleware) {\n return middleware(middlewareAPI);\n });\n _dispatch = compose.apply(undefined, chain)(store.dispatch);\n\n return _extends({}, store, {\n dispatch: _dispatch\n });\n };\n };\n}\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/redux/es/applyMiddleware.js\n// module id = null\n// module chunks = ","import createStore from './createStore';\nimport combineReducers from './combineReducers';\nimport bindActionCreators from './bindActionCreators';\nimport applyMiddleware from './applyMiddleware';\nimport compose from './compose';\nimport warning from './utils/warning';\n\n/*\n* This is a dummy function to check if the function name has been altered by minification.\n* If the function has been minified and NODE_ENV !== 'production', warn the user.\n*/\nfunction isCrushed() {}\n\nif (process.env.NODE_ENV !== 'production' && typeof isCrushed.name === 'string' && isCrushed.name !== 'isCrushed') {\n warning('You are currently using minified code outside of NODE_ENV === \\'production\\'. ' + 'This means that you are running a slower development build of Redux. ' + 'You can use loose-envify (https://github.com/zertosh/loose-envify) for browserify ' + 'or DefinePlugin for webpack (http://stackoverflow.com/questions/30030031) ' + 'to ensure you have the correct code for your production build.');\n}\n\nexport { createStore, combineReducers, bindActionCreators, applyMiddleware, compose };\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/redux/es/index.js\n// module id = null\n// module chunks = ","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 31\n// module chunks = 0","import { dispatchEvent, isElement } from '../lib/utils';\n\nexport default class WrappedElement {\n constructor({ element, classNames }) {\n Object.assign(this, { element, classNames });\n\n if (!isElement(element)) {\n throw new TypeError('Invalid element passed');\n }\n\n this.isDisabled = false;\n }\n\n get value() {\n return this.element.value;\n }\n\n conceal() {\n // Hide passed input\n this.element.classList.add(\n this.classNames.input,\n this.classNames.hiddenState,\n );\n\n // Remove element from tab index\n this.element.tabIndex = '-1';\n\n // Backup original styles if any\n const origStyle = this.element.getAttribute('style');\n\n if (origStyle) {\n this.element.setAttribute('data-choice-orig-style', origStyle);\n }\n\n this.element.setAttribute('aria-hidden', 'true');\n this.element.setAttribute('data-choice', 'active');\n }\n\n reveal() {\n // Reinstate passed element\n this.element.classList.remove(\n this.classNames.input,\n this.classNames.hiddenState,\n );\n this.element.removeAttribute('tabindex');\n\n // Recover original styles if any\n const origStyle = this.element.getAttribute('data-choice-orig-style');\n\n if (origStyle) {\n this.element.removeAttribute('data-choice-orig-style');\n this.element.setAttribute('style', origStyle);\n } else {\n this.element.removeAttribute('style');\n }\n this.element.removeAttribute('aria-hidden');\n this.element.removeAttribute('data-choice');\n\n // Re-assign values - this is weird, I know\n this.element.value = this.element.value;\n }\n\n enable() {\n this.element.removeAttribute('disabled');\n this.element.disabled = false;\n this.isDisabled = false;\n }\n\n disable() {\n this.element.setAttribute('disabled', '');\n this.element.disabled = true;\n this.isDisabled = true;\n }\n\n triggerEvent(eventType, data) {\n dispatchEvent(this.element, eventType, data);\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/components/wrapped-element.js","import classNames from 'classnames';\nimport { strToEl } from './lib/utils';\n\nexport const TEMPLATES = {\n containerOuter(\n globalClasses,\n direction,\n isSelectElement,\n isSelectOneElement,\n searchEnabled,\n passedElementType,\n ) {\n const tabIndex = isSelectOneElement ? 'tabindex=\"0\"' : '';\n let role = isSelectElement ? 'role=\"listbox\"' : '';\n let ariaAutoComplete = '';\n\n if (isSelectElement && searchEnabled) {\n role = 'role=\"combobox\"';\n ariaAutoComplete = 'aria-autocomplete=\"list\"';\n }\n\n return strToEl(`\n \n
\n `);\n },\n containerInner(globalClasses) {\n return strToEl(`\n \n `);\n },\n itemList(globalClasses, isSelectOneElement) {\n const localClasses = classNames(\n globalClasses.list,\n {\n [globalClasses.listSingle]: (isSelectOneElement),\n [globalClasses.listItems]: (!isSelectOneElement),\n },\n );\n\n return strToEl(`\n \n `);\n },\n placeholder(globalClasses, value) {\n return strToEl(`\n \n ${value}\n
\n `);\n },\n item(globalClasses, data, removeItemButton) {\n const ariaSelected = data.active ? 'aria-selected=\"true\"' : '';\n const ariaDisabled = data.disabled ? 'aria-disabled=\"true\"' : '';\n\n let localClasses = classNames(\n globalClasses.item, {\n [globalClasses.highlightedState]: data.highlighted,\n [globalClasses.itemSelectable]: !data.highlighted,\n [globalClasses.placeholder]: data.placeholder,\n },\n );\n\n if (removeItemButton) {\n localClasses = classNames(\n globalClasses.item, {\n [globalClasses.highlightedState]: data.highlighted,\n [globalClasses.itemSelectable]: !data.disabled,\n [globalClasses.placeholder]: data.placeholder,\n },\n );\n\n return strToEl(`\n \n ${data.label}\n
\n `);\n }\n\n return strToEl(`\n \n ${data.label}\n
\n `);\n },\n choiceList(globalClasses, isSelectOneElement) {\n const ariaMultiSelectable = !isSelectOneElement ?\n 'aria-multiselectable=\"true\"' :\n '';\n\n return strToEl(`\n \n
\n `);\n },\n choiceGroup(globalClasses, data) {\n const ariaDisabled = data.disabled ? 'aria-disabled=\"true\"' : '';\n const localClasses = classNames(\n globalClasses.group, {\n [globalClasses.itemDisabled]: data.disabled,\n },\n );\n\n return strToEl(`\n \n `);\n },\n choice(globalClasses, data, itemSelectText) {\n const role = data.groupId > 0 ? 'role=\"treeitem\"' : 'role=\"option\"';\n const localClasses = classNames(\n globalClasses.item,\n globalClasses.itemChoice, {\n [globalClasses.itemDisabled]: data.disabled,\n [globalClasses.itemSelectable]: !data.disabled,\n [globalClasses.placeholder]: data.placeholder,\n },\n );\n\n return strToEl(`\n \n ${data.label}\n
\n `);\n },\n input(globalClasses) {\n const localClasses = classNames(\n globalClasses.input,\n globalClasses.inputCloned,\n );\n\n return strToEl(`\n \n `);\n },\n dropdown(globalClasses) {\n const localClasses = classNames(\n globalClasses.list,\n globalClasses.listDropdown,\n );\n\n return strToEl(`\n \n
\n `);\n },\n notice(globalClasses, label, type = '') {\n const localClasses = classNames(\n globalClasses.item,\n globalClasses.itemChoice,\n {\n [globalClasses.noResults]: (type === 'no-results'),\n [globalClasses.noChoices]: (type === 'no-choices'),\n },\n );\n\n return strToEl(`\n \n ${label}\n
\n `);\n },\n option(data) {\n return strToEl(`\n \n `);\n },\n};\n\nexport default TEMPLATES;\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/templates.js","import Fuse from 'fuse.js';\n\nimport './lib/polyfills';\nimport Store from './store/store';\nimport { Dropdown, Container, Input, List, WrappedInput, WrappedSelect } from './components';\nimport { DEFAULT_CONFIG, DEFAULT_CLASSNAMES, EVENTS, KEY_CODES, SCROLLING_SPEED } from './constants';\nimport { TEMPLATES } from './templates';\nimport { addChoice, filterChoices, activateChoices, clearChoices } from './actions/choices';\nimport { addItem, removeItem, highlightItem } from './actions/items';\nimport { addGroup } from './actions/groups';\nimport { clearAll } from './actions/misc';\nimport {\n isScrolledIntoView,\n getAdjacentEl,\n getType,\n isType,\n strToEl,\n extend,\n sortByAlpha,\n sortByScore,\n generateId,\n findAncestorByAttrName,\n regexFilter,\n isIE11,\n} from './lib/utils';\n\n/**\n * Choices\n */\nclass Choices {\n constructor(element = '[data-choice]', userConfig = {}) {\n if (isType('String', element)) {\n const elements = Array.from(document.querySelectorAll(element));\n\n // If there are multiple elements, create a new instance\n // for each element besides the first one (as that already has an instance)\n if (elements.length > 1) {\n return this._generateInstances(elements, userConfig);\n }\n }\n\n this.config = Choices._generateConfig(userConfig);\n\n if (!['auto', 'always'].includes(this.config.renderSelectedChoices)) {\n this.config.renderSelectedChoices = 'auto';\n }\n\n // Create data store\n this._store = new Store(this.render);\n\n // State tracking\n this.initialised = false;\n this._currentState = {};\n this._prevState = {};\n this._currentValue = '';\n this._isScrollingOnIe = false;\n this._wasTap = true;\n\n // Retrieve triggering element (i.e. element with 'data-choice' trigger)\n const passedElement = isType('String', element) ? document.querySelector(element) : element;\n\n this._isTextElement = passedElement.type === 'text';\n this._isSelectOneElement = passedElement.type === 'select-one';\n this._isSelectMultipleElement = passedElement.type === 'select-multiple';\n this._isSelectElement = this._isSelectOneElement || this._isSelectMultipleElement;\n\n if (this._isTextElement) {\n this.passedElement = new WrappedInput({\n element: passedElement,\n classNames: this.config.classNames,\n delimiter: this.config.delimiter,\n });\n } else if (this._isSelectElement) {\n this.passedElement = new WrappedSelect({\n element: passedElement,\n classNames: this.config.classNames,\n });\n }\n\n if (!this.passedElement) {\n throw new Error('Could not wrap passed element');\n }\n\n if (this.config.shouldSortItems === true && this._isSelectOneElement && !this.config.silent) {\n console.warn('shouldSortElements: Type of passed element is \\'select-one\\', falling back to false.');\n }\n\n this._highlightPosition = 0;\n this._placeholderValue = this._generatePlaceholderValue();\n\n // Assign preset choices from passed object\n this._presetChoices = this.config.choices;\n // Assign preset items from passed object first\n this._presetItems = this.config.items;\n\n // Then add any values passed from attribute\n if (this.passedElement.value) {\n this._presetItems = this._presetItems.concat(\n this.passedElement.value.split(this.config.delimiter),\n );\n }\n\n this._baseId = generateId(this.passedElement.element, 'choices-');\n this._idNames = {\n itemChoice: 'item-choice',\n };\n\n this.render = this.render.bind(this);\n this._onFocus = this._onFocus.bind(this);\n this._onBlur = this._onBlur.bind(this);\n this._onKeyUp = this._onKeyUp.bind(this);\n this._onKeyDown = this._onKeyDown.bind(this);\n this._onClick = this._onClick.bind(this);\n this._onTouchMove = this._onTouchMove.bind(this);\n this._onTouchEnd = this._onTouchEnd.bind(this);\n this._onMouseDown = this._onMouseDown.bind(this);\n this._onMouseOver = this._onMouseOver.bind(this);\n\n // If element has already been initialised with Choices, fail silently\n if (this.passedElement.element.getAttribute('data-choice') === 'active') {\n return false;\n }\n\n // Let's go\n this.init();\n }\n\n /* ========================================\n = Public functions =\n ======================================== */\n\n /**\n * Initialise Choices\n * @return\n * @public\n */\n init() {\n if (this.initialised) {\n return;\n }\n\n // Set initialise flag\n this.initialised = true;\n // Create required templates\n this._createTemplates();\n // Create required elements\n this._createElements();\n // Generate input markup\n this._createStructure();\n // Subscribe store to render method\n this._store.subscribe(this.render);\n // Render any items\n this.render();\n // Trigger event listeners\n this._addEventListeners();\n\n const { callbackOnInit } = this.config;\n // Run callback if it is a function\n if (callbackOnInit && isType('Function', callbackOnInit)) {\n callbackOnInit.call(this);\n }\n }\n\n /**\n * Destroy Choices and nullify values\n * @return\n * @public\n */\n destroy() {\n if (!this.initialised) {\n return;\n }\n\n // Remove all event listeners\n this._removeEventListeners();\n this.passedElement.reveal();\n this.containerOuter.unwrap(this.passedElement.element);\n\n if (this._isSelectElement) {\n this.passedElement.options = this._presetChoices;\n }\n\n // Clear data store\n this.clearStore();\n\n // Nullify instance-specific data\n this.config.templates = null;\n\n // Uninitialise\n this.initialised = false;\n }\n\n /**\n * Enable interaction with Choices\n * @return {Object} Class instance\n */\n enable() {\n if (!this.initialised) {\n return this;\n }\n\n this.passedElement.enable();\n\n if (this.containerOuter.isDisabled) {\n this._addEventListeners();\n this.input.enable();\n this.containerOuter.enable();\n }\n\n return this;\n }\n\n /**\n * Disable interaction with Choices\n * @return {Object} Class instance\n * @public\n */\n disable() {\n if (!this.initialised) {\n return this;\n }\n\n this.passedElement.disable();\n\n if (!this.containerOuter.isDisabled) {\n this._removeEventListeners();\n this.input.disable();\n this.containerOuter.disable();\n }\n\n return this;\n }\n\n /**\n * Render DOM with values\n * @return\n * @private\n */\n render() {\n this._currentState = this._store.state;\n\n const stateChanged = (\n this._currentState.choices !== this._prevState.choices ||\n this._currentState.groups !== this._prevState.groups ||\n this._currentState.items !== this._prevState.items\n );\n const shouldRenderChoices = this._isSelectElement;\n const shouldRenderItems = this._currentState.items !== this._prevState.items;\n\n if (!stateChanged) {\n return;\n }\n\n if (shouldRenderChoices) {\n this._renderChoices();\n }\n\n if (shouldRenderItems) {\n this._renderItems();\n }\n\n this._prevState = this._currentState;\n }\n\n /**\n * Select item (a selected item can be deleted)\n * @param {Element} item Element to select\n * @param {Boolean} [runEvent=true] Whether to trigger 'highlightItem' event\n * @return {Object} Class instance\n * @public\n */\n highlightItem(item, runEvent = true) {\n if (!item) {\n return this;\n }\n\n const { id, groupId = -1, value = '', label = '' } = item;\n const group = groupId >= 0 ? this._store.getGroupById(groupId) : null;\n\n this._store.dispatch(highlightItem(id, true));\n\n if (runEvent) {\n this.passedElement.triggerEvent(EVENTS.highlightItem, {\n id,\n value,\n label,\n groupValue: group && group.value ? group.value : null,\n });\n }\n\n return this;\n }\n\n /**\n * Deselect item\n * @param {Element} item Element to de-select\n * @return {Object} Class instance\n * @public\n */\n unhighlightItem(item) {\n if (!item) {\n return this;\n }\n\n const { id, groupId = -1, value = '', label = '' } = item;\n const group = groupId >= 0 ? this._store.getGroupById(groupId) : null;\n\n this._store.dispatch(highlightItem(id, false));\n this.passedElement.triggerEvent(EVENTS.highlightItem, {\n id,\n value,\n label,\n groupValue: group && group.value ? group.value : null,\n });\n\n return this;\n }\n\n /**\n * Highlight items within store\n * @return {Object} Class instance\n * @public\n */\n highlightAll() {\n this._store.items.forEach(item => this.highlightItem(item));\n return this;\n }\n\n /**\n * Deselect items within store\n * @return {Object} Class instance\n * @public\n */\n unhighlightAll() {\n this._store.items.forEach(item => this.unhighlightItem(item));\n return this;\n }\n\n /**\n * Remove an item from the store by its value\n * @param {String} value Value to search for\n * @return {Object} Class instance\n * @todo Merge with removeActiveItems\n * @public\n */\n removeActiveItemsByValue(value) {\n this._store.activeItems\n .filter(item => item.value === value)\n .forEach(item => this._removeItem(item));\n\n return this;\n }\n\n /**\n * Remove all items from store array\n * @note Removed items are soft deleted\n * @param {Number} excludedId Optionally exclude item by ID\n * @return {Object} Class instance\n * @public\n */\n removeActiveItems(excludedId) {\n this._store.activeItems\n .filter(({ id }) => id !== excludedId)\n .forEach(item => this._removeItem(item));\n\n return this;\n }\n\n /**\n * Remove all selected items from store\n * @note Removed items are soft deleted\n * @return {Object} Class instance\n * @public\n */\n removeHighlightedItems(runEvent = false) {\n this._store.highlightedActiveItems\n .forEach((item) => {\n this._removeItem(item);\n // If this action was performed by the user\n // trigger the event\n if (runEvent) {\n this._triggerChange(item.value);\n }\n });\n\n return this;\n }\n\n /**\n * Show dropdown to user by adding active state class\n * @return {Object} Class instance\n * @public\n */\n showDropdown(focusInput) {\n if (this.dropdown.isActive) {\n return this;\n }\n\n requestAnimationFrame(() => {\n this.dropdown.show();\n this.containerOuter.open(this.dropdown.distanceFromTopWindow());\n\n if (focusInput && this.config.searchEnabled) {\n this.input.focus();\n }\n\n this.passedElement.triggerEvent(EVENTS.showDropdown, {});\n });\n\n return this;\n }\n\n /**\n * Hide dropdown from user\n * @return {Object} Class instance\n * @public\n */\n hideDropdown(blurInput) {\n if (!this.dropdown.isActive) {\n return this;\n }\n\n requestAnimationFrame(() => {\n this.dropdown.hide();\n this.containerOuter.close();\n\n if (blurInput && this.config.searchEnabled) {\n this.input.removeActiveDescendant();\n this.input.blur();\n }\n\n this.passedElement.triggerEvent(EVENTS.hideDropdown, {});\n });\n\n return this;\n }\n\n /**\n * Determine whether to hide or show dropdown based on its current state\n * @return {Object} Class instance\n * @public\n */\n toggleDropdown() {\n if (this.dropdown.isActive) {\n this.hideDropdown();\n } else {\n this.showDropdown(true); // code smell 🤢\n }\n\n return this;\n }\n\n /**\n * Get value(s) of input (i.e. inputted items (text) or selected choices (select))\n * @param {Boolean} valueOnly Get only values of selected items, otherwise return selected items\n * @return {Array/String} selected value (select-one) or\n * array of selected items (inputs & select-multiple)\n * @public\n */\n getValue(valueOnly = false) {\n const values = this._store.activeItems\n .reduce((selectedItems, item) => {\n const itemValue = valueOnly ? item.value : item;\n selectedItems.push(itemValue);\n return selectedItems;\n }, []);\n\n return this._isSelectOneElement ? values[0] : values;\n }\n\n /**\n * Set value of input. If the input is a select box, a choice will\n * be created and selected otherwise an item will created directly.\n * @param {Array} args Array of value objects or value strings\n * @return {Object} Class instance\n * @public\n */\n setValue(args) {\n if (!this.initialised) {\n return this;\n }\n\n // Convert args to an iterable array\n const values = [...args];\n values.forEach(value => this._setChoiceOrItem(value));\n\n return this;\n }\n\n /**\n * Select value of select box via the value of an existing choice\n * @param {Array/String} value An array of strings of a single string\n * @return {Object} Class instance\n * @public\n */\n setChoiceByValue(value) {\n if (!this.initialised || this._isTextElement) {\n return this;\n }\n\n // If only one value has been passed, convert to array\n const choiceValue = isType('Array', value) ? value : [value];\n\n // Loop through each value and\n choiceValue.forEach(val => this._findAndSelectChoiceByValue(val));\n\n return this;\n }\n\n /**\n * Direct populate choices\n * @param {Array} choices - Choices to insert\n * @param {String} value - Name of 'value' property\n * @param {String} label - Name of 'label' property\n * @param {Boolean} replaceChoices Whether existing choices should be removed\n * @return {Object} Class instance\n * @public\n */\n setChoices(choices = [], value = '', label = '', replaceChoices = false) {\n if (\n !this._isSelectElement ||\n !choices.length ||\n !value\n ) {\n return this;\n }\n\n // Clear choices if needed\n if (replaceChoices) {\n this._clearChoices();\n }\n\n this.containerOuter.removeLoadingState();\n const addGroupsAndChoices = (groupOrChoice) => {\n if (groupOrChoice.choices) {\n this._addGroup(\n groupOrChoice,\n (groupOrChoice.id || null),\n value,\n label,\n );\n } else {\n this._addChoice(\n groupOrChoice[value],\n groupOrChoice[label],\n groupOrChoice.selected,\n groupOrChoice.disabled,\n undefined,\n groupOrChoice.customProperties,\n groupOrChoice.placeholder,\n );\n }\n };\n\n choices.forEach(addGroupsAndChoices);\n\n return this;\n }\n\n /**\n * Clear items,choices and groups\n * @note Hard delete\n * @return {Object} Class instance\n * @public\n */\n clearStore() {\n this._store.dispatch(clearAll());\n return this;\n }\n\n /**\n * Set value of input to blank\n * @return {Object} Class instance\n * @public\n */\n clearInput() {\n const shouldSetInputWidth = !this._isSelectOneElement;\n this.input.clear(shouldSetInputWidth);\n\n if (!this._isTextElement && this.config.searchEnabled) {\n this._isSearching = false;\n this._store.dispatch(activateChoices(true));\n }\n\n return this;\n }\n\n /**\n * Populate options via ajax callback\n * @param {Function} fn Function that actually makes an AJAX request\n * @return {Object} Class instance\n * @public\n */\n ajax(fn) {\n if (!this.initialised || !this._isSelectElement || !fn) {\n return this;\n }\n\n requestAnimationFrame(() => this._handleLoadingState(true));\n fn(this._ajaxCallback());\n\n return this;\n }\n\n /* ===== End of Public functions ====== */\n\n /* =============================================\n = Private functions =\n ============================================= */\n\n /**\n * Render group choices into a DOM fragment and append to choice list\n * @param {Array} groups Groups to add to list\n * @param {Array} choices Choices to add to groups\n * @param {DocumentFragment} fragment Fragment to add groups and options to (optional)\n * @return {DocumentFragment} Populated options fragment\n * @private\n */\n _createGroupsFragment(groups, choices, fragment) {\n const groupFragment = fragment || document.createDocumentFragment();\n const getGroupChoices = group => choices.filter((choice) => {\n if (this._isSelectOneElement) {\n return choice.groupId === group.id;\n }\n return choice.groupId === group.id && (this.config.renderSelectedChoices === 'always' || !choice.selected);\n });\n\n\n // If sorting is enabled, filter groups\n if (this.config.shouldSort) {\n groups.sort(this.config.sortFn);\n }\n\n groups.forEach((group) => {\n const groupChoices = getGroupChoices(group);\n if (groupChoices.length >= 1) {\n const dropdownGroup = this._getTemplate('choiceGroup', group);\n groupFragment.appendChild(dropdownGroup);\n this._createChoicesFragment(groupChoices, groupFragment, true);\n }\n });\n\n return groupFragment;\n }\n\n /**\n * Render choices into a DOM fragment and append to choice list\n * @param {Array} choices Choices to add to list\n * @param {DocumentFragment} fragment Fragment to add choices to (optional)\n * @return {DocumentFragment} Populated choices fragment\n * @private\n */\n _createChoicesFragment(choices, fragment, withinGroup = false) {\n // Create a fragment to store our list items (so we don't have to update the DOM for each item)\n const choicesFragment = fragment || document.createDocumentFragment();\n const { renderSelectedChoices, searchResultLimit, renderChoiceLimit } = this.config;\n const filter = this._isSearching ? sortByScore : this.config.sortFn;\n const appendChoice = (choice) => {\n const shouldRender = renderSelectedChoices === 'auto' ?\n (this._isSelectOneElement || !choice.selected) :\n true;\n if (shouldRender) {\n const dropdownItem = this._getTemplate('choice', choice, this.config.itemSelectText);\n choicesFragment.appendChild(dropdownItem);\n }\n };\n\n let rendererableChoices = choices;\n\n if (renderSelectedChoices === 'auto' && !this._isSelectOneElement) {\n rendererableChoices = choices.filter(choice => !choice.selected);\n }\n\n // Split array into placeholders and \"normal\" choices\n const { placeholderChoices, normalChoices } = rendererableChoices.reduce((acc, choice) => {\n if (choice.placeholder) {\n acc.placeholderChoices.push(choice);\n } else {\n acc.normalChoices.push(choice);\n }\n return acc;\n }, { placeholderChoices: [], normalChoices: [] });\n\n // If sorting is enabled or the user is searching, filter choices\n if (this.config.shouldSort || this._isSearching) {\n normalChoices.sort(filter);\n }\n\n let choiceLimit = rendererableChoices.length;\n\n // Prepend placeholeder\n const sortedChoices = [...placeholderChoices, ...normalChoices];\n\n if (this._isSearching) {\n choiceLimit = searchResultLimit;\n } else if (renderChoiceLimit > 0 && !withinGroup) {\n choiceLimit = renderChoiceLimit;\n }\n\n // Add each choice to dropdown within range\n for (let i = 0; i < choiceLimit; i += 1) {\n if (sortedChoices[i]) {\n appendChoice(sortedChoices[i]);\n }\n }\n\n return choicesFragment;\n }\n\n /**\n * Render items into a DOM fragment and append to items list\n * @param {Array} items Items to add to list\n * @param {DocumentFragment} [fragment] Fragment to add items to (optional)\n * @return\n * @private\n */\n _createItemsFragment(items, fragment = null) {\n // Create fragment to add elements to\n const { shouldSortItems, sortFn, removeItemButton } = this.config;\n const itemListFragment = fragment || document.createDocumentFragment();\n\n // If sorting is enabled, filter items\n if (shouldSortItems && !this._isSelectOneElement) {\n items.sort(sortFn);\n }\n\n if (this._isTextElement) {\n // Update the value of the hidden input\n this.passedElement.value = items;\n } else {\n // Update the options of the hidden input\n this.passedElement.options = items;\n }\n\n const addItemToFragment = (item) => {\n // Create new list element\n const listItem = this._getTemplate('item', item, removeItemButton);\n // Append it to list\n itemListFragment.appendChild(listItem);\n };\n\n // Add each list item to list\n items.forEach(item => addItemToFragment(item));\n\n return itemListFragment;\n }\n\n /**\n * Call change callback\n * @param {String} value - last added/deleted/selected value\n * @return\n * @private\n */\n _triggerChange(value) {\n if (value === undefined || value === null) {\n return;\n }\n\n this.passedElement.triggerEvent(EVENTS.change, {\n value,\n });\n }\n\n /**\n * Select placeholder choice\n */\n _selectPlaceholderChoice() {\n const placeholderChoice = this._store.placeholderChoice;\n\n if (placeholderChoice) {\n this._addItem(\n placeholderChoice.value,\n placeholderChoice.label,\n placeholderChoice.id,\n placeholderChoice.groupId,\n null,\n placeholderChoice.placeholder,\n );\n this._triggerChange(placeholderChoice.value);\n }\n }\n\n\n /**\n * Process enter/click of an item button\n * @param {Array} activeItems The currently active items\n * @param {Element} element Button being interacted with\n * @return\n * @private\n */\n _handleButtonAction(activeItems, element) {\n if (\n !activeItems ||\n !element ||\n !this.config.removeItems ||\n !this.config.removeItemButton\n ) {\n return;\n }\n\n const itemId = element.parentNode.getAttribute('data-id');\n const itemToRemove = activeItems.find(item => item.id === parseInt(itemId, 10));\n\n // Remove item associated with button\n this._removeItem(itemToRemove);\n this._triggerChange(itemToRemove.value);\n\n if (this._isSelectOneElement) {\n this._selectPlaceholderChoice();\n }\n }\n\n /**\n * Process click of an item\n * @param {Array} activeItems The currently active items\n * @param {Element} element Item being interacted with\n * @param {Boolean} hasShiftKey Whether the user has the shift key active\n * @return\n * @private\n */\n _handleItemAction(activeItems, element, hasShiftKey = false) {\n if (\n !activeItems ||\n !element ||\n !this.config.removeItems ||\n this._isSelectOneElement\n ) {\n return;\n }\n\n const passedId = element.getAttribute('data-id');\n\n // We only want to select one item with a click\n // so we deselect any items that aren't the target\n // unless shift is being pressed\n activeItems.forEach((item) => {\n if (item.id === parseInt(passedId, 10) && !item.highlighted) {\n this.highlightItem(item);\n } else if (!hasShiftKey && item.highlighted) {\n this.unhighlightItem(item);\n }\n });\n\n // Focus input as without focus, a user cannot do anything with a\n // highlighted item\n this.input.focus();\n }\n\n /**\n * Process click of a choice\n * @param {Array} activeItems The currently active items\n * @param {Element} element Choice being interacted with\n * @return\n */\n _handleChoiceAction(activeItems, element) {\n if (!activeItems || !element) {\n return;\n }\n\n // If we are clicking on an option\n const id = element.getAttribute('data-id');\n const choice = this._store.getChoiceById(id);\n const passedKeyCode = activeItems[0] && activeItems[0].keyCode ? activeItems[0].keyCode : null;\n const hasActiveDropdown = this.dropdown.isActive;\n\n // Update choice keyCode\n choice.keyCode = passedKeyCode;\n\n this.passedElement.triggerEvent(EVENTS.choice, {\n choice,\n });\n\n if (choice && !choice.selected && !choice.disabled) {\n const canAddItem = this._canAddItem(activeItems, choice.value);\n\n if (canAddItem.response) {\n this._addItem(\n choice.value,\n choice.label,\n choice.id,\n choice.groupId,\n choice.customProperties,\n choice.placeholder,\n choice.keyCode,\n );\n this._triggerChange(choice.value);\n }\n }\n\n this.clearInput();\n\n // We wont to close the dropdown if we are dealing with a single select box\n if (hasActiveDropdown && this._isSelectOneElement) {\n this.hideDropdown();\n this.containerOuter.focus();\n }\n }\n\n /**\n * Process back space event\n * @param {Array} activeItems items\n * @return\n * @private\n */\n _handleBackspace(activeItems) {\n if (!this.config.removeItems || !activeItems) {\n return;\n }\n\n const lastItem = activeItems[activeItems.length - 1];\n const hasHighlightedItems = activeItems.some(item => item.highlighted);\n\n // If editing the last item is allowed and there are not other selected items,\n // we can edit the item value. Otherwise if we can remove items, remove all selected items\n if (this.config.editItems && !hasHighlightedItems && lastItem) {\n this.input.value = lastItem.value;\n this.input.setWidth();\n this._removeItem(lastItem);\n this._triggerChange(lastItem.value);\n } else {\n if (!hasHighlightedItems) {\n // Highlight last item if none already highlighted\n this.highlightItem(lastItem, false);\n }\n this.removeHighlightedItems(true);\n }\n }\n\n /**\n * Apply or remove a loading state to the component.\n * @param {Boolean} isLoading default value set to 'true'.\n * @return\n * @private\n */\n _handleLoadingState(isLoading = true) {\n let placeholderItem = this.itemList.getChild(`.${this.config.classNames.placeholder}`);\n if (isLoading) {\n this.containerOuter.addLoadingState();\n if (this._isSelectOneElement) {\n if (!placeholderItem) {\n placeholderItem = this._getTemplate('placeholder', this.config.loadingText);\n this.itemList.append(placeholderItem);\n } else {\n placeholderItem.innerHTML = this.config.loadingText;\n }\n } else {\n this.input.placeholder = this.config.loadingText;\n }\n } else {\n this.containerOuter.removeLoadingState();\n\n if (this._isSelectOneElement) {\n placeholderItem.innerHTML = (this._placeholderValue || '');\n } else {\n this.input.placeholder = (this._placeholderValue || '');\n }\n }\n }\n\n\n /**\n * Validates whether an item can be added by a user\n * @param {Array} activeItems The currently active items\n * @param {String} value Value of item to add\n * @return {Object} Response: Whether user can add item\n * Notice: Notice show in dropdown\n */\n _canAddItem(activeItems, value) {\n let canAddItem = true;\n let notice = isType('Function', this.config.addItemText) ?\n this.config.addItemText(value) :\n this.config.addItemText;\n\n if (this._isSelectMultipleElement || this._isTextElement) {\n if (this.config.maxItemCount > 0 && this.config.maxItemCount <= activeItems.length) {\n // If there is a max entry limit and we have reached that limit\n // don't update\n canAddItem = false;\n notice = isType('Function', this.config.maxItemText) ?\n this.config.maxItemText(this.config.maxItemCount) :\n this.config.maxItemText;\n }\n }\n\n if (this.config.regexFilter && this._isTextElement && this.config.addItems && canAddItem) {\n // If a user has supplied a regular expression filter\n // determine whether we can update based on whether\n // our regular expression passes\n canAddItem = regexFilter(value, this.config.regexFilter);\n }\n\n // If no duplicates are allowed, and the value already exists\n // in the array\n const isUnique = !activeItems.some((item) => {\n if (isType('String', value)) {\n return item.value === value.trim();\n }\n\n return item.value === value;\n });\n\n if (!isUnique &&\n !this.config.duplicateItems &&\n !this._isSelectOneElement &&\n canAddItem\n ) {\n canAddItem = false;\n notice = isType('Function', this.config.uniqueItemText) ?\n this.config.uniqueItemText(value) :\n this.config.uniqueItemText;\n }\n\n return {\n response: canAddItem,\n notice,\n };\n }\n\n /**\n * Retrieve the callback used to populate component's choices in an async way.\n * @returns {Function} The callback as a function.\n * @private\n */\n _ajaxCallback() {\n return (results, value, label) => {\n if (!results || !value) {\n return;\n }\n\n const parsedResults = isType('Object', results) ? [results] : results;\n\n if (parsedResults && isType('Array', parsedResults) && parsedResults.length) {\n // Remove loading states/text\n this._handleLoadingState(false);\n // Add each result as a choice\n parsedResults.forEach((result) => {\n if (result.choices) {\n const groupId = (result.id || null);\n this._addGroup(\n result,\n groupId,\n value,\n label,\n );\n } else {\n this._addChoice(\n result[value],\n result[label],\n result.selected,\n result.disabled,\n undefined,\n result.customProperties,\n result.placeholder,\n );\n }\n });\n\n if (this._isSelectOneElement) {\n this._selectPlaceholderChoice();\n }\n } else {\n // No results, remove loading state\n this._handleLoadingState(false);\n }\n };\n }\n\n /**\n * Filter choices based on search value\n * @param {String} value Value to filter by\n * @return\n * @private\n */\n _searchChoices(value) {\n const newValue = isType('String', value) ? value.trim() : value;\n const currentValue = isType('String', this._currentValue) ?\n this._currentValue.trim() :\n this._currentValue;\n\n if (newValue.length < 1 && newValue === `${currentValue} `) {\n return 0;\n }\n\n // If new value matches the desired length and is not the same as the current value with a space\n const haystack = this._store.searchableChoices;\n const needle = newValue;\n const keys = isType('Array', this.config.searchFields) ?\n this.config.searchFields :\n [this.config.searchFields];\n const options = Object.assign(this.config.fuseOptions, { keys });\n const fuse = new Fuse(haystack, options);\n const results = fuse.search(needle);\n\n this._currentValue = newValue;\n this._highlightPosition = 0;\n this._isSearching = true;\n this._store.dispatch(filterChoices(results));\n\n return results.length;\n }\n\n /**\n * Determine the action when a user is searching\n * @param {String} value Value entered by user\n * @return\n * @private\n */\n _handleSearch(value) {\n if (!value || !this.input.isFocussed) {\n return;\n }\n\n const choices = this._store.choices;\n const { searchFloor, searchChoices } = this.config;\n const hasUnactiveChoices = choices.some(option => !option.active);\n\n // Check that we have a value to search and the input was an alphanumeric character\n if (value && value.length >= searchFloor) {\n const resultCount = searchChoices ? this._searchChoices(value) : 0;\n // Trigger search event\n this.passedElement.triggerEvent(EVENTS.search, {\n value,\n resultCount,\n });\n } else if (hasUnactiveChoices) {\n // Otherwise reset choices to active\n this._isSearching = false;\n this._store.dispatch(activateChoices(true));\n }\n }\n\n /**\n * Trigger event listeners\n * @return\n * @private\n */\n _addEventListeners() {\n document.addEventListener('keyup', this._onKeyUp);\n document.addEventListener('keydown', this._onKeyDown);\n document.addEventListener('click', this._onClick);\n document.addEventListener('touchmove', this._onTouchMove);\n document.addEventListener('touchend', this._onTouchEnd);\n document.addEventListener('mousedown', this._onMouseDown);\n document.addEventListener('mouseover', this._onMouseOver);\n\n if (this._isSelectOneElement) {\n this.containerOuter.element.addEventListener('focus', this._onFocus);\n this.containerOuter.element.addEventListener('blur', this._onBlur);\n }\n\n this.input.element.addEventListener('focus', this._onFocus);\n this.input.element.addEventListener('blur', this._onBlur);\n\n this.input.addEventListeners();\n }\n\n /**\n * Remove event listeners\n * @return\n * @private\n */\n _removeEventListeners() {\n document.removeEventListener('keyup', this._onKeyUp);\n document.removeEventListener('keydown', this._onKeyDown);\n document.removeEventListener('click', this._onClick);\n document.removeEventListener('touchmove', this._onTouchMove);\n document.removeEventListener('touchend', this._onTouchEnd);\n document.removeEventListener('mousedown', this._onMouseDown);\n document.removeEventListener('mouseover', this._onMouseOver);\n\n if (this._isSelectOneElement) {\n this.containerOuter.element.removeEventListener('focus', this._onFocus);\n this.containerOuter.element.removeEventListener('blur', this._onBlur);\n }\n\n this.input.element.removeEventListener('focus', this._onFocus);\n this.input.element.removeEventListener('blur', this._onBlur);\n this.input.removeEventListeners();\n }\n\n /**\n * Key down event\n * @param {Object} e Event\n * @return\n */\n _onKeyDown(e) {\n if (e.target !== this.input.element && !this.containerOuter.element.contains(e.target)) {\n return;\n }\n\n const target = e.target;\n const activeItems = this._store.activeItems;\n const hasFocusedInput = this.input.isFocussed;\n const hasActiveDropdown = this.dropdown.isActive;\n const hasItems = this.itemList.hasChildren;\n const keyString = String.fromCharCode(e.keyCode);\n const backKey = KEY_CODES.BACK_KEY;\n const deleteKey = KEY_CODES.DELETE_KEY;\n const enterKey = KEY_CODES.ENTER_KEY;\n const aKey = KEY_CODES.A_KEY;\n const escapeKey = KEY_CODES.ESC_KEY;\n const upKey = KEY_CODES.UP_KEY;\n const downKey = KEY_CODES.DOWN_KEY;\n const pageUpKey = KEY_CODES.PAGE_UP_KEY;\n const pageDownKey = KEY_CODES.PAGE_DOWN_KEY;\n const ctrlDownKey = (e.ctrlKey || e.metaKey);\n\n // If a user is typing and the dropdown is not active\n if (!this._isTextElement && /[a-zA-Z0-9-_ ]/.test(keyString)) {\n this.showDropdown(true);\n }\n\n this.config.searchEnabled = this.config.searchEnabled;\n\n const onAKey = () => {\n // If CTRL + A or CMD + A have been pressed and there are items to select\n if (ctrlDownKey && hasItems) {\n this.config.searchEnabled = false;\n if (\n this.config.removeItems &&\n !this.input.value &&\n this.input.element === document.activeElement\n ) {\n // Highlight items\n this.highlightAll();\n }\n }\n };\n\n const onEnterKey = () => {\n // If enter key is pressed and the input has a value\n if (this._isTextElement && target.value) {\n const value = this.input.value;\n const canAddItem = this._canAddItem(activeItems, value);\n\n // All is good, add\n if (canAddItem.response) {\n this.hideDropdown();\n this._addItem(value);\n this._triggerChange(value);\n this.clearInput();\n }\n }\n\n if (target.hasAttribute('data-button')) {\n this._handleButtonAction(activeItems, target);\n e.preventDefault();\n }\n\n if (hasActiveDropdown) {\n e.preventDefault();\n const highlighted = this.dropdown.getChild(`.${this.config.classNames.highlightedState}`);\n\n // If we have a highlighted choice\n if (highlighted) {\n // add enter keyCode value\n if (activeItems[0]) {\n activeItems[0].keyCode = enterKey;\n }\n this._handleChoiceAction(activeItems, highlighted);\n }\n } else if (this._isSelectOneElement) {\n // Open single select dropdown if it's not active\n this.showDropdown(true);\n e.preventDefault();\n }\n };\n\n const onEscapeKey = () => {\n if (hasActiveDropdown) {\n this.hideDropdown();\n this.containerOuter.focus();\n }\n };\n\n const onDirectionKey = () => {\n // If up or down key is pressed, traverse through options\n if (hasActiveDropdown || this._isSelectOneElement) {\n // Show dropdown if focus\n this.showDropdown(true);\n\n this.config.searchEnabled = false;\n\n const directionInt = e.keyCode === downKey || e.keyCode === pageDownKey ? 1 : -1;\n const skipKey = e.metaKey || e.keyCode === pageDownKey || e.keyCode === pageUpKey;\n const selectableChoiceIdentifier = '[data-choice-selectable]';\n\n let nextEl;\n if (skipKey) {\n if (directionInt > 0) {\n nextEl = Array.from(\n this.dropdown.element.querySelectorAll(selectableChoiceIdentifier),\n ).pop();\n } else {\n nextEl = this.dropdown.element.querySelector(selectableChoiceIdentifier);\n }\n } else {\n const currentEl = this.dropdown.element.querySelector(\n `.${this.config.classNames.highlightedState}`,\n );\n if (currentEl) {\n nextEl = getAdjacentEl(currentEl, selectableChoiceIdentifier, directionInt);\n } else {\n nextEl = this.dropdown.element.querySelector(selectableChoiceIdentifier);\n }\n }\n\n if (nextEl) {\n // We prevent default to stop the cursor moving\n // when pressing the arrow\n if (!isScrolledIntoView(nextEl, this.choiceList.element, directionInt)) {\n this._scrollToChoice(nextEl, directionInt);\n }\n this._highlightChoice(nextEl);\n }\n\n // Prevent default to maintain cursor position whilst\n // traversing dropdown options\n e.preventDefault();\n }\n };\n\n const onDeleteKey = () => {\n // If backspace or delete key is pressed and the input has no value\n if (hasFocusedInput && !e.target.value && !this._isSelectOneElement) {\n this._handleBackspace(activeItems);\n e.preventDefault();\n }\n };\n\n // Map keys to key actions\n const keyDownActions = {\n [aKey]: onAKey,\n [enterKey]: onEnterKey,\n [escapeKey]: onEscapeKey,\n [upKey]: onDirectionKey,\n [pageUpKey]: onDirectionKey,\n [downKey]: onDirectionKey,\n [pageDownKey]: onDirectionKey,\n [deleteKey]: onDeleteKey,\n [backKey]: onDeleteKey,\n };\n\n // If keycode has a function, run it\n if (keyDownActions[e.keyCode]) {\n keyDownActions[e.keyCode]();\n }\n }\n\n /**\n * Key up event\n * @param {Object} e Event\n * @return\n * @private\n */\n _onKeyUp(e) {\n if (e.target !== this.input.element) {\n return;\n }\n\n const value = this.input.value;\n const activeItems = this._store.activeItems;\n const canAddItem = this._canAddItem(activeItems, value);\n\n // We are typing into a text input and have a value, we want to show a dropdown\n // notice. Otherwise hide the dropdown\n if (this._isTextElement) {\n if (value) {\n if (canAddItem.notice) {\n const dropdownItem = this._getTemplate('notice', canAddItem.notice);\n this.dropdown.element.innerHTML = dropdownItem.outerHTML;\n }\n\n if (canAddItem.response === true) {\n this.showDropdown();\n } else if (!canAddItem.notice) {\n this.hideDropdown();\n }\n } else {\n this.hideDropdown();\n }\n } else {\n const backKey = KEY_CODES.BACK_KEY;\n const deleteKey = KEY_CODES.DELETE_KEY;\n\n // If user has removed value...\n if ((e.keyCode === backKey || e.keyCode === deleteKey) && !e.target.value) {\n // ...and it is a multiple select input, activate choices (if searching)\n if (!this._isTextElement && this._isSearching) {\n this._isSearching = false;\n this._store.dispatch(activateChoices(true));\n }\n } else if (this.config.searchEnabled && canAddItem.response) {\n this._handleSearch(this.input.value);\n }\n }\n // Re-establish canSearch value from changes in _onKeyDown\n this.config.searchEnabled = this.config.searchEnabled;\n }\n\n /**\n * Touch move event\n * @return\n * @private\n */\n _onTouchMove() {\n if (this._wasTap === true) {\n this._wasTap = false;\n }\n }\n\n /**\n * Touch end event\n * @param {Object} e Event\n * @return\n * @private\n */\n _onTouchEnd(e) {\n const target = (e.target || e.touches[0].target);\n\n // If a user tapped within our container...\n if (this._wasTap === true && this.containerOuter.element.contains(target)) {\n // ...and we aren't dealing with a single select box, show dropdown/focus input\n if (\n (target === this.containerOuter.element || target === this.containerInner.element) &&\n !this._isSelectOneElement\n ) {\n if (this._isTextElement) {\n // If text element, we only want to focus the input\n this.input.focus();\n } else {\n // If a select box, we want to show the dropdown\n this.showDropdown(true);\n }\n }\n // Prevents focus event firing\n e.stopPropagation();\n }\n\n this._wasTap = true;\n }\n\n /**\n * Mouse down event\n * @param {Object} e Event\n * @return\n * @private\n */\n _onMouseDown(e) {\n const target = e.target;\n\n // If we have our mouse down on the scrollbar and are on IE11...\n if (target === this.choiceList && isIE11()) {\n this._isScrollingOnIe = true;\n }\n\n if (this.containerOuter.element.contains(target) && target !== this.input.element) {\n const activeItems = this._store.activeItems;\n const hasShiftKey = e.shiftKey;\n\n const buttonTarget = findAncestorByAttrName(target, 'data-button');\n const itemTarget = findAncestorByAttrName(target, 'data-item');\n const choiceTarget = findAncestorByAttrName(target, 'data-choice');\n\n if (buttonTarget) {\n this._handleButtonAction(activeItems, buttonTarget);\n } else if (itemTarget) {\n this._handleItemAction(activeItems, itemTarget, hasShiftKey);\n } else if (choiceTarget) {\n this._handleChoiceAction(activeItems, choiceTarget);\n }\n\n e.preventDefault();\n }\n }\n\n /**\n * Mouse over (hover) event\n * @param {Object} e Event\n * @return\n * @private\n */\n _onMouseOver(e) {\n // If the dropdown is either the target or one of its children is the target\n const targetWithinDropdown = (\n e.target === this.dropdown || this.dropdown.element.contains(e.target)\n );\n const shouldHighlightChoice = targetWithinDropdown && e.target.hasAttribute('data-choice');\n\n if (shouldHighlightChoice) {\n this._highlightChoice(e.target);\n }\n }\n\n /**\n * Click event\n * @param {Object} e Event\n * @return\n * @private\n */\n _onClick(e) {\n const target = e.target;\n const hasActiveDropdown = this.dropdown.isActive;\n const activeItems = this._store.activeItems;\n\n // If target is something that concerns us\n if (this.containerOuter.element.contains(target)) {\n if (!hasActiveDropdown) {\n if (this._isTextElement) {\n if (document.activeElement !== this.input.element) {\n this.input.focus();\n }\n } else if (this.config.searchEnabled) {\n this.showDropdown(true);\n } else {\n this.showDropdown();\n // code smell\n this.containerOuter.focus();\n }\n } else if (\n this._isSelectOneElement &&\n target !== this.input.element &&\n !this.dropdown.element.contains(target)\n ) {\n this.hideDropdown(true);\n }\n } else {\n const hasHighlightedItems = activeItems.some(item => item.highlighted);\n\n // De-select any highlighted items\n if (hasHighlightedItems) {\n this.unhighlightAll();\n }\n\n // Remove focus state\n this.containerOuter.removeFocusState();\n\n // Close all other dropdowns\n this.hideDropdown();\n }\n }\n\n /**\n * Focus event\n * @param {Object} e Event\n * @return\n * @private\n */\n _onFocus(e) {\n const target = e.target;\n if (!this.containerOuter.element.contains(target)) {\n return;\n }\n\n const focusActions = {\n text: () => {\n if (target === this.input.element) {\n this.containerOuter.addFocusState();\n }\n },\n 'select-one': () => {\n this.containerOuter.addFocusState();\n if (target === this.input.element) {\n // Show dropdown if it isn't already showing\n this.showDropdown();\n }\n },\n 'select-multiple': () => {\n if (target === this.input.element) {\n // If element is a select box, the focused element is the container and the dropdown\n // isn't already open, focus and show dropdown\n this.containerOuter.addFocusState();\n this.showDropdown(true);\n }\n },\n };\n\n focusActions[this.passedElement.element.type]();\n }\n\n /**\n * Blur event\n * @param {Object} e Event\n * @return\n * @private\n */\n _onBlur(e) {\n const target = e.target;\n // If target is something that concerns us\n if (this.containerOuter.element.contains(target) && !this._isScrollingOnIe) {\n const activeItems = this._store.activeItems;\n const hasHighlightedItems = activeItems.some(item => item.highlighted);\n const blurActions = {\n text: () => {\n if (target === this.input.element) {\n // Remove the focus state\n this.containerOuter.removeFocusState();\n // De-select any highlighted items\n if (hasHighlightedItems) {\n this.unhighlightAll();\n }\n this.hideDropdown();\n }\n },\n 'select-one': () => {\n this.containerOuter.removeFocusState();\n if (target === this.input.element ||\n (target === this.containerOuter.element && !this.config.searchEnabled)) {\n this.hideDropdown();\n }\n },\n 'select-multiple': () => {\n if (target === this.input.element) {\n // Remove the focus state\n this.containerOuter.removeFocusState();\n this.hideDropdown();\n // De-select any highlighted items\n if (hasHighlightedItems) {\n this.unhighlightAll();\n }\n }\n },\n };\n\n blurActions[this.passedElement.element.type]();\n } else {\n // On IE11, clicking the scollbar blurs our input and thus\n // closes the dropdown. To stop this, we refocus our input\n // if we know we are on IE *and* are scrolling.\n this._isScrollingOnIe = false;\n this.input.element.focus();\n }\n }\n\n /**\n * Scroll to an option element\n * @param {HTMLElement} choice Option to scroll to\n * @param {Number} direction Whether option is above or below\n * @return\n * @private\n */\n _scrollToChoice(choice, direction) {\n if (!choice) {\n return;\n }\n\n const dropdownHeight = this.choiceList.element.offsetHeight;\n const choiceHeight = choice.offsetHeight;\n // Distance from bottom of element to top of parent\n const choicePos = choice.offsetTop + choiceHeight;\n // Scroll position of dropdown\n const containerScrollPos = this.choiceList.element.scrollTop + dropdownHeight;\n // Difference between the choice and scroll position\n const endPoint = direction > 0 ? (\n (this.choiceList.element.scrollTop + choicePos) - containerScrollPos\n ) : choice.offsetTop;\n\n const animateScroll = () => {\n const strength = SCROLLING_SPEED;\n const choiceListScrollTop = this.choiceList.element.scrollTop;\n let continueAnimation = false;\n let easing;\n let distance;\n\n if (direction > 0) {\n easing = (endPoint - choiceListScrollTop) / strength;\n distance = easing > 1 ? easing : 1;\n\n this.choiceList.scrollTo(choiceListScrollTop + distance);\n if (choiceListScrollTop < endPoint) {\n continueAnimation = true;\n }\n } else {\n easing = (choiceListScrollTop - endPoint) / strength;\n distance = easing > 1 ? easing : 1;\n\n this.choiceList.scrollTo(choiceListScrollTop - distance);\n if (choiceListScrollTop > endPoint) {\n continueAnimation = true;\n }\n }\n\n if (continueAnimation) {\n requestAnimationFrame((time) => {\n animateScroll(time, endPoint, direction);\n });\n }\n };\n\n requestAnimationFrame((time) => {\n animateScroll(time, endPoint, direction);\n });\n }\n\n /**\n * Highlight choice\n * @param {HTMLElement} [el] Element to highlight\n * @return\n * @private\n */\n _highlightChoice(el = null) {\n // Highlight first element in dropdown\n const choices = Array.from(this.dropdown.element.querySelectorAll('[data-choice-selectable]'));\n\n if (!choices.length) {\n return;\n }\n\n let passedEl = el;\n const highlightedChoices = Array.from(\n this.dropdown.element.querySelectorAll(`.${this.config.classNames.highlightedState}`),\n );\n const hasActiveDropdown = this.dropdown.isActive;\n\n // Remove any highlighted choices\n highlightedChoices.forEach((choice) => {\n choice.classList.remove(this.config.classNames.highlightedState);\n choice.setAttribute('aria-selected', 'false');\n });\n\n if (passedEl) {\n this._highlightPosition = choices.indexOf(passedEl);\n } else {\n // Highlight choice based on last known highlight location\n if (choices.length > this._highlightPosition) {\n // If we have an option to highlight\n passedEl = choices[this._highlightPosition];\n } else {\n // Otherwise highlight the option before\n passedEl = choices[choices.length - 1];\n }\n\n if (!passedEl) {\n passedEl = choices[0];\n }\n }\n\n // Highlight given option, and set accessiblity attributes\n passedEl.classList.add(this.config.classNames.highlightedState);\n passedEl.setAttribute('aria-selected', 'true');\n\n if (hasActiveDropdown) {\n // IE11 ignores aria-label and blocks virtual keyboard\n // if aria-activedescendant is set without a dropdown\n this.input.setActiveDescendant(passedEl.id);\n this.containerOuter.setActiveDescendant(passedEl.id);\n }\n }\n\n /**\n * Add item to store with correct value\n * @param {String} value Value to add to store\n * @param {String} [label] Label to add to store\n * @param {Number} [choiceId=-1] ID of the associated choice that was selected\n * @param {Number} [groupId=-1] ID of group choice is within. Negative number indicates no group\n * @param {Object} [customProperties] Object containing user defined properties\n * @return {Object} Class instance\n * @public\n */\n _addItem(\n value,\n label = null,\n choiceId = -1,\n groupId = -1,\n customProperties = null,\n placeholder = false,\n keyCode = null,\n ) {\n let passedValue = isType('String', value) ? value.trim() : value;\n\n const passedKeyCode = keyCode;\n const passedCustomProperties = customProperties;\n const items = this._store.items;\n const passedLabel = label || passedValue;\n const passedOptionId = parseInt(choiceId, 10) || -1;\n const group = groupId >= 0 ? this._store.getGroupById(groupId) : null;\n const id = items ? items.length + 1 : 1;\n\n // If a prepended value has been passed, prepend it\n if (this.config.prependValue) {\n passedValue = this.config.prependValue + passedValue.toString();\n }\n\n // If an appended value has been passed, append it\n if (this.config.appendValue) {\n passedValue += this.config.appendValue.toString();\n }\n\n this._store.dispatch(\n addItem(\n passedValue,\n passedLabel,\n id,\n passedOptionId,\n groupId,\n customProperties,\n placeholder,\n passedKeyCode,\n ),\n );\n\n if (this._isSelectOneElement) {\n this.removeActiveItems(id);\n }\n\n // Trigger change event\n if (group && group.value) {\n this.passedElement.triggerEvent(EVENTS.addItem, {\n id,\n value: passedValue,\n label: passedLabel,\n customProperties: passedCustomProperties,\n groupValue: group.value,\n keyCode: passedKeyCode,\n });\n } else {\n this.passedElement.triggerEvent(EVENTS.addItem, {\n id,\n value: passedValue,\n label: passedLabel,\n customProperties: passedCustomProperties,\n keyCode: passedKeyCode,\n });\n }\n\n return this;\n }\n\n /**\n * Remove item from store\n * @param {Object} item Item to remove\n * @return {Object} Class instance\n * @public\n */\n _removeItem(item) {\n if (!item || !isType('Object', item)) {\n return this;\n }\n\n const { id, value, label, choiceId, groupId } = item;\n const group = groupId >= 0 ? this._store.getGroupById(groupId) : null;\n\n this._store.dispatch(removeItem(id, choiceId));\n\n if (group && group.value) {\n this.passedElement.triggerEvent(EVENTS.removeItem, {\n id,\n value,\n label,\n groupValue: group.value,\n });\n } else {\n this.passedElement.triggerEvent(EVENTS.removeItem, {\n id,\n value,\n label,\n });\n }\n\n return this;\n }\n\n /**\n * Add choice to dropdown\n * @param {String} value Value of choice\n * @param {String} [label] Label of choice\n * @param {Boolean} [isSelected=false] Whether choice is selected\n * @param {Boolean} [isDisabled=false] Whether choice is disabled\n * @param {Number} [groupId=-1] ID of group choice is within. Negative number indicates no group\n * @param {Object} [customProperties] Object containing user defined properties\n * @return\n * @private\n */\n _addChoice(\n value,\n label = null,\n isSelected = false,\n isDisabled = false,\n groupId = -1,\n customProperties = null,\n placeholder = false,\n keyCode = null,\n ) {\n if (typeof value === 'undefined' || value === null) {\n return;\n }\n\n // Generate unique id\n const choices = this._store.choices;\n const choiceLabel = label || value;\n const choiceId = choices ? choices.length + 1 : 1;\n const choiceElementId = `${this._baseId}-${this._idNames.itemChoice}-${choiceId}`;\n\n this._store.dispatch(\n addChoice(\n value,\n choiceLabel,\n choiceId,\n groupId,\n isDisabled,\n choiceElementId,\n customProperties,\n placeholder,\n keyCode,\n ),\n );\n\n if (isSelected) {\n this._addItem(\n value,\n choiceLabel,\n choiceId,\n undefined,\n customProperties,\n placeholder,\n keyCode,\n );\n }\n }\n\n /**\n * Clear all choices added to the store.\n * @return\n * @private\n */\n _clearChoices() {\n this._store.dispatch(clearChoices());\n }\n\n /**\n * Add group to dropdown\n * @param {Object} group Group to add\n * @param {Number} id Group ID\n * @param {String} [valueKey] name of the value property on the object\n * @param {String} [labelKey] name of the label property on the object\n * @return\n * @private\n */\n _addGroup(group, id, valueKey = 'value', labelKey = 'label') {\n const groupChoices = isType('Object', group) ?\n group.choices :\n Array.from(group.getElementsByTagName('OPTION'));\n const groupId = id || Math.floor(new Date().valueOf() * Math.random());\n const isDisabled = group.disabled ? group.disabled : false;\n\n if (groupChoices) {\n this._store.dispatch(\n addGroup(\n group.label,\n groupId,\n true,\n isDisabled,\n ),\n );\n\n const addGroupChoices = (choice) => {\n const isOptDisabled = choice.disabled || (choice.parentNode && choice.parentNode.disabled);\n this._addChoice(\n choice[valueKey],\n (isType('Object', choice)) ? choice[labelKey] : choice.innerHTML,\n choice.selected,\n isOptDisabled,\n groupId,\n choice.customProperties,\n choice.placeholder,\n );\n };\n\n groupChoices.forEach(addGroupChoices);\n } else {\n this._store.dispatch(\n addGroup(\n group.label,\n group.id,\n false,\n group.disabled,\n ),\n );\n }\n }\n\n /**\n * Get template from name\n * @param {String} template Name of template to get\n * @param {...} args Data to pass to template\n * @return {HTMLElement} Template\n * @private\n */\n _getTemplate(template, ...args) {\n if (!template) {\n return null;\n }\n\n const templates = this.config.templates;\n const globalClasses = this.config.classNames;\n\n return templates[template].call(this, globalClasses, ...args);\n }\n\n /**\n * Create HTML element based on type and arguments\n * @return\n * @private\n */\n _createTemplates() {\n const { callbackOnCreateTemplates } = this.config;\n let userTemplates = {};\n\n if (callbackOnCreateTemplates && isType('Function', callbackOnCreateTemplates)) {\n userTemplates = callbackOnCreateTemplates.call(this, strToEl);\n }\n\n this.config.templates = extend(TEMPLATES, userTemplates);\n }\n\n /**\n * Create DOM elements using templates\n */\n _createElements() {\n const direction = this.passedElement.element.getAttribute('dir') || 'ltr';\n const containerOuter = this._getTemplate('containerOuter',\n direction,\n this._isSelectElement,\n this._isSelectOneElement,\n this.config.searchEnabled,\n this.passedElement.element.type,\n );\n const containerInner = this._getTemplate('containerInner');\n const itemList = this._getTemplate('itemList', this._isSelectOneElement);\n const choiceList = this._getTemplate('choiceList', this._isSelectOneElement);\n const input = this._getTemplate('input');\n const dropdown = this._getTemplate('dropdown');\n\n this.containerOuter = new Container({\n element: containerOuter,\n classNames: this.config.classNames,\n type: this.passedElement.element.type,\n position: this.config.position,\n });\n\n this.containerInner = new Container({\n element: containerInner,\n classNames: this.config.classNames,\n type: this.passedElement.element.type,\n position: this.config.position,\n });\n\n this.input = new Input({\n element: input,\n classNames: this.config.classNames,\n type: this.passedElement.element.type,\n });\n\n this.choiceList = new List({\n element: choiceList,\n });\n\n this.itemList = new List({\n element: itemList,\n });\n\n this.dropdown = new Dropdown({\n element: dropdown,\n classNames: this.config.classNames,\n type: this.passedElement.element.type,\n });\n }\n\n /**\n * Create DOM structure around passed select element\n * @return\n * @private\n */\n _createStructure() {\n // Hide original element\n this.passedElement.conceal();\n // Wrap input in container preserving DOM ordering\n this.containerInner.wrap(this.passedElement.element);\n // Wrapper inner container with outer container\n this.containerOuter.wrap(this.containerInner.element);\n\n if (this._isSelectOneElement) {\n this.input.placeholder = (this.config.searchPlaceholderValue || '');\n } else if (this._placeholderValue) {\n this.input.placeholder = this._placeholderValue;\n this.input.setWidth(true);\n }\n\n if (!this.config.addItems) {\n this.disable();\n }\n\n this.containerOuter.element.appendChild(this.containerInner.element);\n this.containerOuter.element.appendChild(this.dropdown.element);\n this.containerInner.element.appendChild(this.itemList.element);\n\n if (!this._isTextElement) {\n this.dropdown.element.appendChild(this.choiceList.element);\n }\n\n if (!this._isSelectOneElement) {\n this.containerInner.element.appendChild(this.input.element);\n } else if (this.config.searchEnabled) {\n this.dropdown.element.insertBefore(this.input.element, this.dropdown.element.firstChild);\n }\n\n if (this._isSelectElement) {\n this._addPredefinedChoices();\n } else if (this._isTextElement) {\n this._addPredefinedItems();\n }\n }\n\n _addPredefinedChoices() {\n const passedGroups = this.passedElement.optionGroups;\n\n this._highlightPosition = 0;\n this._isSearching = false;\n\n if (passedGroups && passedGroups.length) {\n // If we have a placeholder option\n const placeholderChoice = this.passedElement.placeholderOption;\n if (placeholderChoice && placeholderChoice.parentNode.tagName === 'SELECT') {\n this._addChoice(\n placeholderChoice.value,\n placeholderChoice.innerHTML,\n placeholderChoice.selected,\n placeholderChoice.disabled,\n undefined,\n undefined,\n /* placeholder */ true,\n );\n }\n\n passedGroups.forEach((group) => {\n this._addGroup(group, (group.id || null));\n });\n } else {\n const passedOptions = this.passedElement.options;\n const filter = this.config.sortFn;\n const allChoices = this._presetChoices;\n\n // Create array of options from option elements\n passedOptions.forEach((o) => {\n allChoices.push({\n value: o.value,\n label: o.innerHTML,\n selected: o.selected,\n disabled: o.disabled || o.parentNode.disabled,\n placeholder: o.hasAttribute('placeholder'),\n });\n });\n\n // If sorting is enabled or the user is searching, filter choices\n if (this.config.shouldSort) {\n allChoices.sort(filter);\n }\n\n // Determine whether there is a selected choice\n const hasSelectedChoice = allChoices.some(choice => choice.selected);\n const handleChoice = (choice, index) => {\n if (this._isSelectElement) {\n // If the choice is actually a group\n if (choice.choices) {\n this._addGroup(choice, choice.id || null);\n } else {\n // If there is a selected choice already or the choice is not\n // the first in the array, add each choice normally\n // Otherwise pre-select the first choice in the array if it's a single select\n const shouldPreselect = this._isSelectOneElement && !hasSelectedChoice && index === 0;\n const isSelected = shouldPreselect ? true : choice.selected;\n const isDisabled = shouldPreselect ? false : choice.disabled;\n\n this._addChoice(\n choice.value,\n choice.label,\n isSelected,\n isDisabled,\n undefined,\n choice.customProperties,\n choice.placeholder,\n );\n }\n } else {\n this._addChoice(\n choice.value,\n choice.label,\n choice.selected,\n choice.disabled,\n undefined,\n choice.customProperties,\n choice.placeholder,\n );\n }\n };\n\n // Add each choice\n allChoices.forEach((choice, index) => handleChoice(choice, index));\n }\n }\n\n _addPredefinedItems() {\n const handlePresetItem = (item) => {\n const itemType = getType(item);\n if (itemType === 'Object') {\n if (!item.value) {\n return;\n }\n this._addItem(\n item.value,\n item.label,\n item.id,\n undefined,\n item.customProperties,\n item.placeholder,\n );\n } else if (itemType === 'String') {\n this._addItem(item);\n }\n };\n\n this._presetItems.forEach(item => handlePresetItem(item));\n }\n\n _setChoiceOrItem(item) {\n const itemType = getType(item).toLowerCase();\n const handleType = {\n object: () => {\n if (!item.value) {\n return;\n }\n\n // If we are dealing with a select input, we need to create an option first\n // that is then selected. For text inputs we can just add items normally.\n if (!this._isTextElement) {\n this._addChoice(\n item.value,\n item.label,\n true,\n false, -1,\n item.customProperties,\n item.placeholder,\n );\n } else {\n this._addItem(\n item.value,\n item.label,\n item.id,\n undefined,\n item.customProperties,\n item.placeholder,\n );\n }\n },\n string: () => {\n if (!this._isTextElement) {\n this._addChoice(\n item,\n item,\n true,\n false, -1,\n null,\n );\n } else {\n this._addItem(item);\n }\n },\n };\n\n handleType[itemType]();\n }\n\n _findAndSelectChoiceByValue(val) {\n const choices = this._store.choices;\n // Check 'value' property exists and the choice isn't already selected\n const foundChoice = choices.find(choice => this.config.itemComparer(choice.value, val));\n\n if (foundChoice && !foundChoice.selected) {\n this._addItem(\n foundChoice.value,\n foundChoice.label,\n foundChoice.id,\n foundChoice.groupId,\n foundChoice.customProperties,\n foundChoice.placeholder,\n foundChoice.keyCode,\n );\n }\n }\n\n _generateInstances(elements, config) {\n return elements.reduce((instances, element) => {\n instances.push(new Choices(element, config));\n return instances;\n }, [this]);\n }\n\n static _generateConfig(userConfig) {\n const defaultConfig = {\n ...DEFAULT_CONFIG,\n items: [],\n choices: [],\n classNames: DEFAULT_CLASSNAMES,\n sortFn: sortByAlpha,\n };\n\n return extend(defaultConfig, Choices.userDefaults, userConfig);\n }\n\n _generatePlaceholderValue() {\n if (!this._isSelectOneElement) {\n return this.config.placeholder ?\n (this.config.placeholderValue || this.passedElement.element.getAttribute('placeholder')) :\n false;\n }\n\n return false;\n }\n\n _renderChoices() {\n // Get active groups/choices\n const activeGroups = this._store.activeGroups;\n const activeChoices = this._store.activeChoices;\n\n let choiceListFragment = document.createDocumentFragment();\n\n // Clear choices\n this.choiceList.clear();\n\n // Scroll back to top of choices list\n if (this.config.resetScrollPosition) {\n this.choiceList.scrollTo(0);\n }\n\n // If we have grouped options\n if (activeGroups.length >= 1 && !this._isSearching) {\n // If we have a placeholder choice along with groups\n const activePlaceholders = activeChoices.filter(\n activeChoice => activeChoice.placeholder === true && activeChoice.groupId === -1,\n );\n if (activePlaceholders.length >= 1) {\n choiceListFragment = this._createChoicesFragment(activePlaceholders, choiceListFragment);\n }\n choiceListFragment = this._createGroupsFragment(\n activeGroups,\n activeChoices,\n choiceListFragment,\n );\n } else if (activeChoices.length >= 1) {\n choiceListFragment = this._createChoicesFragment(activeChoices, choiceListFragment);\n }\n\n // If we have choices to show\n if (choiceListFragment.childNodes && choiceListFragment.childNodes.length > 0) {\n const activeItems = this._store.activeItems;\n const canAddItem = this._canAddItem(activeItems, this.input.value);\n\n // ...and we can select them\n if (canAddItem.response) {\n // ...append them and highlight the first choice\n this.choiceList.append(choiceListFragment);\n this._highlightChoice();\n } else {\n // ...otherwise show a notice\n this.choiceList.append(this._getTemplate('notice', canAddItem.notice));\n }\n } else {\n // Otherwise show a notice\n let dropdownItem;\n let notice;\n\n if (this._isSearching) {\n notice = isType('Function', this.config.noResultsText) ?\n this.config.noResultsText() :\n this.config.noResultsText;\n\n dropdownItem = this._getTemplate('notice', notice, 'no-results');\n } else {\n notice = isType('Function', this.config.noChoicesText) ?\n this.config.noChoicesText() :\n this.config.noChoicesText;\n\n dropdownItem = this._getTemplate('notice', notice, 'no-choices');\n }\n\n this.choiceList.append(dropdownItem);\n }\n }\n\n _renderItems() {\n // Get active items (items that can be selected)\n const activeItems = this._store.activeItems || [];\n // Clear list\n this.itemList.clear();\n\n if (activeItems.length) {\n // Create a fragment to store our list items\n // (so we don't have to update the DOM for each item)\n const itemListFragment = this._createItemsFragment(activeItems);\n\n // If we have items to add, append them\n if (itemListFragment.childNodes) {\n this.itemList.append(itemListFragment);\n }\n }\n }\n\n /* ===== End of Private functions ====== */\n}\n\nChoices.userDefaults = {};\n\n// We cannot export default here due to Webpack: https://github.com/webpack/webpack/issues/3929\nmodule.exports = Choices;\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/choices.js","/*!\n * Fuse.js v3.2.0 - Lightweight fuzzy-search (http://fusejs.io)\n * \n * Copyright (c) 2012-2017 Kirollos Risk (http://kiro.me)\n * All Rights Reserved. Apache Software License 2.0\n * \n * http://www.apache.org/licenses/LICENSE-2.0\n */\n(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"Fuse\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Fuse\"] = factory();\n\telse\n\t\troot[\"Fuse\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// identity function for calling harmony imports with the correct context\n/******/ \t__webpack_require__.i = function(value) { return value; };\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 8);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = function (obj) {\n return Object.prototype.toString.call(obj) === '[object Array]';\n};\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar bitapRegexSearch = __webpack_require__(5);\nvar bitapSearch = __webpack_require__(7);\nvar patternAlphabet = __webpack_require__(4);\n\nvar Bitap = function () {\n function Bitap(pattern, _ref) {\n var _ref$location = _ref.location,\n location = _ref$location === undefined ? 0 : _ref$location,\n _ref$distance = _ref.distance,\n distance = _ref$distance === undefined ? 100 : _ref$distance,\n _ref$threshold = _ref.threshold,\n threshold = _ref$threshold === undefined ? 0.6 : _ref$threshold,\n _ref$maxPatternLength = _ref.maxPatternLength,\n maxPatternLength = _ref$maxPatternLength === undefined ? 32 : _ref$maxPatternLength,\n _ref$isCaseSensitive = _ref.isCaseSensitive,\n isCaseSensitive = _ref$isCaseSensitive === undefined ? false : _ref$isCaseSensitive,\n _ref$tokenSeparator = _ref.tokenSeparator,\n tokenSeparator = _ref$tokenSeparator === undefined ? / +/g : _ref$tokenSeparator,\n _ref$findAllMatches = _ref.findAllMatches,\n findAllMatches = _ref$findAllMatches === undefined ? false : _ref$findAllMatches,\n _ref$minMatchCharLeng = _ref.minMatchCharLength,\n minMatchCharLength = _ref$minMatchCharLeng === undefined ? 1 : _ref$minMatchCharLeng;\n\n _classCallCheck(this, Bitap);\n\n this.options = {\n location: location,\n distance: distance,\n threshold: threshold,\n maxPatternLength: maxPatternLength,\n isCaseSensitive: isCaseSensitive,\n tokenSeparator: tokenSeparator,\n findAllMatches: findAllMatches,\n minMatchCharLength: minMatchCharLength\n };\n\n this.pattern = this.options.isCaseSensitive ? pattern : pattern.toLowerCase();\n\n if (this.pattern.length <= maxPatternLength) {\n this.patternAlphabet = patternAlphabet(this.pattern);\n }\n }\n\n _createClass(Bitap, [{\n key: 'search',\n value: function search(text) {\n if (!this.options.isCaseSensitive) {\n text = text.toLowerCase();\n }\n\n // Exact match\n if (this.pattern === text) {\n return {\n isMatch: true,\n score: 0,\n matchedIndices: [[0, text.length - 1]]\n };\n }\n\n // When pattern length is greater than the machine word length, just do a a regex comparison\n var _options = this.options,\n maxPatternLength = _options.maxPatternLength,\n tokenSeparator = _options.tokenSeparator;\n\n if (this.pattern.length > maxPatternLength) {\n return bitapRegexSearch(text, this.pattern, tokenSeparator);\n }\n\n // Otherwise, use Bitap algorithm\n var _options2 = this.options,\n location = _options2.location,\n distance = _options2.distance,\n threshold = _options2.threshold,\n findAllMatches = _options2.findAllMatches,\n minMatchCharLength = _options2.minMatchCharLength;\n\n return bitapSearch(text, this.pattern, this.patternAlphabet, {\n location: location,\n distance: distance,\n threshold: threshold,\n findAllMatches: findAllMatches,\n minMatchCharLength: minMatchCharLength\n });\n }\n }]);\n\n return Bitap;\n}();\n\n// let x = new Bitap(\"od mn war\", {})\n// let result = x.search(\"Old Man's War\")\n// console.log(result)\n\nmodule.exports = Bitap;\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar isArray = __webpack_require__(0);\n\nvar deepValue = function deepValue(obj, path, list) {\n if (!path) {\n // If there's no path left, we've gotten to the object we care about.\n list.push(obj);\n } else {\n var dotIndex = path.indexOf('.');\n var firstSegment = path;\n var remaining = null;\n\n if (dotIndex !== -1) {\n firstSegment = path.slice(0, dotIndex);\n remaining = path.slice(dotIndex + 1);\n }\n\n var value = obj[firstSegment];\n\n if (value !== null && value !== undefined) {\n if (!remaining && (typeof value === 'string' || typeof value === 'number')) {\n list.push(value.toString());\n } else if (isArray(value)) {\n // Search each item in the array.\n for (var i = 0, len = value.length; i < len; i += 1) {\n deepValue(value[i], remaining, list);\n }\n } else if (remaining) {\n // An object. Recurse further.\n deepValue(value, remaining, list);\n }\n }\n }\n\n return list;\n};\n\nmodule.exports = function (obj, path) {\n return deepValue(obj, path, []);\n};\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = function () {\n var matchmask = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n var minMatchCharLength = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;\n\n var matchedIndices = [];\n var start = -1;\n var end = -1;\n var i = 0;\n\n for (var len = matchmask.length; i < len; i += 1) {\n var match = matchmask[i];\n if (match && start === -1) {\n start = i;\n } else if (!match && start !== -1) {\n end = i - 1;\n if (end - start + 1 >= minMatchCharLength) {\n matchedIndices.push([start, end]);\n }\n start = -1;\n }\n }\n\n // (i-1 - start) + 1 => i - start\n if (matchmask[i - 1] && i - start >= minMatchCharLength) {\n matchedIndices.push([start, i - 1]);\n }\n\n return matchedIndices;\n};\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = function (pattern) {\n var mask = {};\n var len = pattern.length;\n\n for (var i = 0; i < len; i += 1) {\n mask[pattern.charAt(i)] = 0;\n }\n\n for (var _i = 0; _i < len; _i += 1) {\n mask[pattern.charAt(_i)] |= 1 << len - _i - 1;\n }\n\n return mask;\n};\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar SPECIAL_CHARS_REGEX = /[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g;\n\nmodule.exports = function (text, pattern) {\n var tokenSeparator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : / +/g;\n\n var regex = new RegExp(pattern.replace(SPECIAL_CHARS_REGEX, '\\\\$&').replace(tokenSeparator, '|'));\n var matches = text.match(regex);\n var isMatch = !!matches;\n var matchedIndices = [];\n\n if (isMatch) {\n for (var i = 0, matchesLen = matches.length; i < matchesLen; i += 1) {\n var match = matches[i];\n matchedIndices.push([text.indexOf(match), match.length - 1]);\n }\n }\n\n return {\n // TODO: revisit this score\n score: isMatch ? 0.5 : 1,\n isMatch: isMatch,\n matchedIndices: matchedIndices\n };\n};\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = function (pattern, _ref) {\n var _ref$errors = _ref.errors,\n errors = _ref$errors === undefined ? 0 : _ref$errors,\n _ref$currentLocation = _ref.currentLocation,\n currentLocation = _ref$currentLocation === undefined ? 0 : _ref$currentLocation,\n _ref$expectedLocation = _ref.expectedLocation,\n expectedLocation = _ref$expectedLocation === undefined ? 0 : _ref$expectedLocation,\n _ref$distance = _ref.distance,\n distance = _ref$distance === undefined ? 100 : _ref$distance;\n\n var accuracy = errors / pattern.length;\n var proximity = Math.abs(expectedLocation - currentLocation);\n\n if (!distance) {\n // Dodge divide by zero error.\n return proximity ? 1.0 : accuracy;\n }\n\n return accuracy + proximity / distance;\n};\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar bitapScore = __webpack_require__(6);\nvar matchedIndices = __webpack_require__(3);\n\nmodule.exports = function (text, pattern, patternAlphabet, _ref) {\n var _ref$location = _ref.location,\n location = _ref$location === undefined ? 0 : _ref$location,\n _ref$distance = _ref.distance,\n distance = _ref$distance === undefined ? 100 : _ref$distance,\n _ref$threshold = _ref.threshold,\n threshold = _ref$threshold === undefined ? 0.6 : _ref$threshold,\n _ref$findAllMatches = _ref.findAllMatches,\n findAllMatches = _ref$findAllMatches === undefined ? false : _ref$findAllMatches,\n _ref$minMatchCharLeng = _ref.minMatchCharLength,\n minMatchCharLength = _ref$minMatchCharLeng === undefined ? 1 : _ref$minMatchCharLeng;\n\n var expectedLocation = location;\n // Set starting location at beginning text and initialize the alphabet.\n var textLen = text.length;\n // Highest score beyond which we give up.\n var currentThreshold = threshold;\n // Is there a nearby exact match? (speedup)\n var bestLocation = text.indexOf(pattern, expectedLocation);\n\n var patternLen = pattern.length;\n\n // a mask of the matches\n var matchMask = [];\n for (var i = 0; i < textLen; i += 1) {\n matchMask[i] = 0;\n }\n\n if (bestLocation !== -1) {\n var score = bitapScore(pattern, {\n errors: 0,\n currentLocation: bestLocation,\n expectedLocation: expectedLocation,\n distance: distance\n });\n currentThreshold = Math.min(score, currentThreshold);\n\n // What about in the other direction? (speed up)\n bestLocation = text.lastIndexOf(pattern, expectedLocation + patternLen);\n\n if (bestLocation !== -1) {\n var _score = bitapScore(pattern, {\n errors: 0,\n currentLocation: bestLocation,\n expectedLocation: expectedLocation,\n distance: distance\n });\n currentThreshold = Math.min(_score, currentThreshold);\n }\n }\n\n // Reset the best location\n bestLocation = -1;\n\n var lastBitArr = [];\n var finalScore = 1;\n var binMax = patternLen + textLen;\n\n var mask = 1 << patternLen - 1;\n\n for (var _i = 0; _i < patternLen; _i += 1) {\n // Scan for the best match; each iteration allows for one more error.\n // Run a binary search to determine how far from the match location we can stray\n // at this error level.\n var binMin = 0;\n var binMid = binMax;\n\n while (binMin < binMid) {\n var _score3 = bitapScore(pattern, {\n errors: _i,\n currentLocation: expectedLocation + binMid,\n expectedLocation: expectedLocation,\n distance: distance\n });\n\n if (_score3 <= currentThreshold) {\n binMin = binMid;\n } else {\n binMax = binMid;\n }\n\n binMid = Math.floor((binMax - binMin) / 2 + binMin);\n }\n\n // Use the result from this iteration as the maximum for the next.\n binMax = binMid;\n\n var start = Math.max(1, expectedLocation - binMid + 1);\n var finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen;\n\n // Initialize the bit array\n var bitArr = Array(finish + 2);\n\n bitArr[finish + 1] = (1 << _i) - 1;\n\n for (var j = finish; j >= start; j -= 1) {\n var currentLocation = j - 1;\n var charMatch = patternAlphabet[text.charAt(currentLocation)];\n\n if (charMatch) {\n matchMask[currentLocation] = 1;\n }\n\n // First pass: exact match\n bitArr[j] = (bitArr[j + 1] << 1 | 1) & charMatch;\n\n // Subsequent passes: fuzzy match\n if (_i !== 0) {\n bitArr[j] |= (lastBitArr[j + 1] | lastBitArr[j]) << 1 | 1 | lastBitArr[j + 1];\n }\n\n if (bitArr[j] & mask) {\n finalScore = bitapScore(pattern, {\n errors: _i,\n currentLocation: currentLocation,\n expectedLocation: expectedLocation,\n distance: distance\n });\n\n // This match will almost certainly be better than any existing match.\n // But check anyway.\n if (finalScore <= currentThreshold) {\n // Indeed it is\n currentThreshold = finalScore;\n bestLocation = currentLocation;\n\n // Already passed `loc`, downhill from here on in.\n if (bestLocation <= expectedLocation) {\n break;\n }\n\n // When passing `bestLocation`, don't exceed our current distance from `expectedLocation`.\n start = Math.max(1, 2 * expectedLocation - bestLocation);\n }\n }\n }\n\n // No hope for a (better) match at greater error levels.\n var _score2 = bitapScore(pattern, {\n errors: _i + 1,\n currentLocation: expectedLocation,\n expectedLocation: expectedLocation,\n distance: distance\n });\n\n if (_score2 > currentThreshold) {\n break;\n }\n\n lastBitArr = bitArr;\n }\n\n // Count exact matches (those with a score of 0) to be \"almost\" exact\n return {\n isMatch: bestLocation >= 0,\n score: finalScore === 0 ? 0.001 : finalScore,\n matchedIndices: matchedIndices(matchMask, minMatchCharLength)\n };\n};\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Bitap = __webpack_require__(1);\nvar deepValue = __webpack_require__(2);\nvar isArray = __webpack_require__(0);\n\nvar Fuse = function () {\n function Fuse(list, _ref) {\n var _ref$location = _ref.location,\n location = _ref$location === undefined ? 0 : _ref$location,\n _ref$distance = _ref.distance,\n distance = _ref$distance === undefined ? 100 : _ref$distance,\n _ref$threshold = _ref.threshold,\n threshold = _ref$threshold === undefined ? 0.6 : _ref$threshold,\n _ref$maxPatternLength = _ref.maxPatternLength,\n maxPatternLength = _ref$maxPatternLength === undefined ? 32 : _ref$maxPatternLength,\n _ref$caseSensitive = _ref.caseSensitive,\n caseSensitive = _ref$caseSensitive === undefined ? false : _ref$caseSensitive,\n _ref$tokenSeparator = _ref.tokenSeparator,\n tokenSeparator = _ref$tokenSeparator === undefined ? / +/g : _ref$tokenSeparator,\n _ref$findAllMatches = _ref.findAllMatches,\n findAllMatches = _ref$findAllMatches === undefined ? false : _ref$findAllMatches,\n _ref$minMatchCharLeng = _ref.minMatchCharLength,\n minMatchCharLength = _ref$minMatchCharLeng === undefined ? 1 : _ref$minMatchCharLeng,\n _ref$id = _ref.id,\n id = _ref$id === undefined ? null : _ref$id,\n _ref$keys = _ref.keys,\n keys = _ref$keys === undefined ? [] : _ref$keys,\n _ref$shouldSort = _ref.shouldSort,\n shouldSort = _ref$shouldSort === undefined ? true : _ref$shouldSort,\n _ref$getFn = _ref.getFn,\n getFn = _ref$getFn === undefined ? deepValue : _ref$getFn,\n _ref$sortFn = _ref.sortFn,\n sortFn = _ref$sortFn === undefined ? function (a, b) {\n return a.score - b.score;\n } : _ref$sortFn,\n _ref$tokenize = _ref.tokenize,\n tokenize = _ref$tokenize === undefined ? false : _ref$tokenize,\n _ref$matchAllTokens = _ref.matchAllTokens,\n matchAllTokens = _ref$matchAllTokens === undefined ? false : _ref$matchAllTokens,\n _ref$includeMatches = _ref.includeMatches,\n includeMatches = _ref$includeMatches === undefined ? false : _ref$includeMatches,\n _ref$includeScore = _ref.includeScore,\n includeScore = _ref$includeScore === undefined ? false : _ref$includeScore,\n _ref$verbose = _ref.verbose,\n verbose = _ref$verbose === undefined ? false : _ref$verbose;\n\n _classCallCheck(this, Fuse);\n\n this.options = {\n location: location,\n distance: distance,\n threshold: threshold,\n maxPatternLength: maxPatternLength,\n isCaseSensitive: caseSensitive,\n tokenSeparator: tokenSeparator,\n findAllMatches: findAllMatches,\n minMatchCharLength: minMatchCharLength,\n id: id,\n keys: keys,\n includeMatches: includeMatches,\n includeScore: includeScore,\n shouldSort: shouldSort,\n getFn: getFn,\n sortFn: sortFn,\n verbose: verbose,\n tokenize: tokenize,\n matchAllTokens: matchAllTokens\n };\n\n this.setCollection(list);\n }\n\n _createClass(Fuse, [{\n key: 'setCollection',\n value: function setCollection(list) {\n this.list = list;\n return list;\n }\n }, {\n key: 'search',\n value: function search(pattern) {\n this._log('---------\\nSearch pattern: \"' + pattern + '\"');\n\n var _prepareSearchers2 = this._prepareSearchers(pattern),\n tokenSearchers = _prepareSearchers2.tokenSearchers,\n fullSearcher = _prepareSearchers2.fullSearcher;\n\n var _search2 = this._search(tokenSearchers, fullSearcher),\n weights = _search2.weights,\n results = _search2.results;\n\n this._computeScore(weights, results);\n\n if (this.options.shouldSort) {\n this._sort(results);\n }\n\n return this._format(results);\n }\n }, {\n key: '_prepareSearchers',\n value: function _prepareSearchers() {\n var pattern = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n\n var tokenSearchers = [];\n\n if (this.options.tokenize) {\n // Tokenize on the separator\n var tokens = pattern.split(this.options.tokenSeparator);\n for (var i = 0, len = tokens.length; i < len; i += 1) {\n tokenSearchers.push(new Bitap(tokens[i], this.options));\n }\n }\n\n var fullSearcher = new Bitap(pattern, this.options);\n\n return { tokenSearchers: tokenSearchers, fullSearcher: fullSearcher };\n }\n }, {\n key: '_search',\n value: function _search() {\n var tokenSearchers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n var fullSearcher = arguments[1];\n\n var list = this.list;\n var resultMap = {};\n var results = [];\n\n // Check the first item in the list, if it's a string, then we assume\n // that every item in the list is also a string, and thus it's a flattened array.\n if (typeof list[0] === 'string') {\n // Iterate over every item\n for (var i = 0, len = list.length; i < len; i += 1) {\n this._analyze({\n key: '',\n value: list[i],\n record: i,\n index: i\n }, {\n resultMap: resultMap,\n results: results,\n tokenSearchers: tokenSearchers,\n fullSearcher: fullSearcher\n });\n }\n\n return { weights: null, results: results };\n }\n\n // Otherwise, the first item is an Object (hopefully), and thus the searching\n // is done on the values of the keys of each item.\n var weights = {};\n for (var _i = 0, _len = list.length; _i < _len; _i += 1) {\n var item = list[_i];\n // Iterate over every key\n for (var j = 0, keysLen = this.options.keys.length; j < keysLen; j += 1) {\n var key = this.options.keys[j];\n if (typeof key !== 'string') {\n weights[key.name] = {\n weight: 1 - key.weight || 1\n };\n if (key.weight <= 0 || key.weight > 1) {\n throw new Error('Key weight has to be > 0 and <= 1');\n }\n key = key.name;\n } else {\n weights[key] = {\n weight: 1\n };\n }\n\n this._analyze({\n key: key,\n value: this.options.getFn(item, key),\n record: item,\n index: _i\n }, {\n resultMap: resultMap,\n results: results,\n tokenSearchers: tokenSearchers,\n fullSearcher: fullSearcher\n });\n }\n }\n\n return { weights: weights, results: results };\n }\n }, {\n key: '_analyze',\n value: function _analyze(_ref2, _ref3) {\n var key = _ref2.key,\n _ref2$arrayIndex = _ref2.arrayIndex,\n arrayIndex = _ref2$arrayIndex === undefined ? -1 : _ref2$arrayIndex,\n value = _ref2.value,\n record = _ref2.record,\n index = _ref2.index;\n var _ref3$tokenSearchers = _ref3.tokenSearchers,\n tokenSearchers = _ref3$tokenSearchers === undefined ? [] : _ref3$tokenSearchers,\n _ref3$fullSearcher = _ref3.fullSearcher,\n fullSearcher = _ref3$fullSearcher === undefined ? [] : _ref3$fullSearcher,\n _ref3$resultMap = _ref3.resultMap,\n resultMap = _ref3$resultMap === undefined ? {} : _ref3$resultMap,\n _ref3$results = _ref3.results,\n results = _ref3$results === undefined ? [] : _ref3$results;\n\n // Check if the texvaluet can be searched\n if (value === undefined || value === null) {\n return;\n }\n\n var exists = false;\n var averageScore = -1;\n var numTextMatches = 0;\n\n if (typeof value === 'string') {\n this._log('\\nKey: ' + (key === '' ? '-' : key));\n\n var mainSearchResult = fullSearcher.search(value);\n this._log('Full text: \"' + value + '\", score: ' + mainSearchResult.score);\n\n if (this.options.tokenize) {\n var words = value.split(this.options.tokenSeparator);\n var scores = [];\n\n for (var i = 0; i < tokenSearchers.length; i += 1) {\n var tokenSearcher = tokenSearchers[i];\n\n this._log('\\nPattern: \"' + tokenSearcher.pattern + '\"');\n\n // let tokenScores = []\n var hasMatchInText = false;\n\n for (var j = 0; j < words.length; j += 1) {\n var word = words[j];\n var tokenSearchResult = tokenSearcher.search(word);\n var obj = {};\n if (tokenSearchResult.isMatch) {\n obj[word] = tokenSearchResult.score;\n exists = true;\n hasMatchInText = true;\n scores.push(tokenSearchResult.score);\n } else {\n obj[word] = 1;\n if (!this.options.matchAllTokens) {\n scores.push(1);\n }\n }\n this._log('Token: \"' + word + '\", score: ' + obj[word]);\n // tokenScores.push(obj)\n }\n\n if (hasMatchInText) {\n numTextMatches += 1;\n }\n }\n\n averageScore = scores[0];\n var scoresLen = scores.length;\n for (var _i2 = 1; _i2 < scoresLen; _i2 += 1) {\n averageScore += scores[_i2];\n }\n averageScore = averageScore / scoresLen;\n\n this._log('Token score average:', averageScore);\n }\n\n var finalScore = mainSearchResult.score;\n if (averageScore > -1) {\n finalScore = (finalScore + averageScore) / 2;\n }\n\n this._log('Score average:', finalScore);\n\n var checkTextMatches = this.options.tokenize && this.options.matchAllTokens ? numTextMatches >= tokenSearchers.length : true;\n\n this._log('\\nCheck Matches: ' + checkTextMatches);\n\n // If a match is found, add the item to , including its score\n if ((exists || mainSearchResult.isMatch) && checkTextMatches) {\n // Check if the item already exists in our results\n var existingResult = resultMap[index];\n if (existingResult) {\n // Use the lowest score\n // existingResult.score, bitapResult.score\n existingResult.output.push({\n key: key,\n arrayIndex: arrayIndex,\n value: value,\n score: finalScore,\n matchedIndices: mainSearchResult.matchedIndices\n });\n } else {\n // Add it to the raw result list\n resultMap[index] = {\n item: record,\n output: [{\n key: key,\n arrayIndex: arrayIndex,\n value: value,\n score: finalScore,\n matchedIndices: mainSearchResult.matchedIndices\n }]\n };\n\n results.push(resultMap[index]);\n }\n }\n } else if (isArray(value)) {\n for (var _i3 = 0, len = value.length; _i3 < len; _i3 += 1) {\n this._analyze({\n key: key,\n arrayIndex: _i3,\n value: value[_i3],\n record: record,\n index: index\n }, {\n resultMap: resultMap,\n results: results,\n tokenSearchers: tokenSearchers,\n fullSearcher: fullSearcher\n });\n }\n }\n }\n }, {\n key: '_computeScore',\n value: function _computeScore(weights, results) {\n this._log('\\n\\nComputing score:\\n');\n\n for (var i = 0, len = results.length; i < len; i += 1) {\n var output = results[i].output;\n var scoreLen = output.length;\n\n var totalScore = 0;\n var bestScore = 1;\n\n for (var j = 0; j < scoreLen; j += 1) {\n var weight = weights ? weights[output[j].key].weight : 1;\n var score = weight === 1 ? output[j].score : output[j].score || 0.001;\n var nScore = score * weight;\n\n if (weight !== 1) {\n bestScore = Math.min(bestScore, nScore);\n } else {\n output[j].nScore = nScore;\n totalScore += nScore;\n }\n }\n\n results[i].score = bestScore === 1 ? totalScore / scoreLen : bestScore;\n\n this._log(results[i]);\n }\n }\n }, {\n key: '_sort',\n value: function _sort(results) {\n this._log('\\n\\nSorting....');\n results.sort(this.options.sortFn);\n }\n }, {\n key: '_format',\n value: function _format(results) {\n var finalOutput = [];\n\n this._log('\\n\\nOutput:\\n\\n', JSON.stringify(results));\n\n var transformers = [];\n\n if (this.options.includeMatches) {\n transformers.push(function (result, data) {\n var output = result.output;\n data.matches = [];\n\n for (var i = 0, len = output.length; i < len; i += 1) {\n var item = output[i];\n\n if (item.matchedIndices.length === 0) {\n continue;\n }\n\n var obj = {\n indices: item.matchedIndices,\n value: item.value\n };\n if (item.key) {\n obj.key = item.key;\n }\n if (item.hasOwnProperty('arrayIndex') && item.arrayIndex > -1) {\n obj.arrayIndex = item.arrayIndex;\n }\n data.matches.push(obj);\n }\n });\n }\n\n if (this.options.includeScore) {\n transformers.push(function (result, data) {\n data.score = result.score;\n });\n }\n\n for (var i = 0, len = results.length; i < len; i += 1) {\n var result = results[i];\n\n if (this.options.id) {\n result.item = this.options.getFn(result.item, this.options.id)[0];\n }\n\n if (!transformers.length) {\n finalOutput.push(result.item);\n continue;\n }\n\n var data = {\n item: result.item\n };\n\n for (var j = 0, _len2 = transformers.length; j < _len2; j += 1) {\n transformers[j](result, data);\n }\n\n finalOutput.push(data);\n }\n\n return finalOutput;\n }\n }, {\n key: '_log',\n value: function _log() {\n if (this.options.verbose) {\n var _console;\n\n (_console = console).log.apply(_console, arguments);\n }\n }\n }]);\n\n return Fuse;\n}();\n\nmodule.exports = Fuse;\n\n/***/ })\n/******/ ]);\n});\n//# sourceMappingURL=fuse.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/fuse.js/dist/fuse.js\n// module id = 36\n// module chunks = 0","import 'core-js/fn/array/from';\nimport 'custom-event-polyfill';\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/lib/polyfills.js","require('../../modules/es6.string.iterator');\nrequire('../../modules/es6.array.from');\nmodule.exports = require('../../modules/_core').Array.from;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/fn/array/from.js\n// module id = 38\n// module chunks = 0","'use strict';\nvar $at = require('./_string-at')(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\nrequire('./_iter-define')(String, 'String', function (iterated) {\n this._t = String(iterated); // target\n this._i = 0; // next index\n// 21.1.5.2.1 %StringIteratorPrototype%.next()\n}, function () {\n var O = this._t;\n var index = this._i;\n var point;\n if (index >= O.length) return { value: undefined, done: true };\n point = $at(O, index);\n this._i += point.length;\n return { value: point, done: false };\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/es6.string.iterator.js\n// module id = 39\n// module chunks = 0","var toInteger = require('./_to-integer');\nvar defined = require('./_defined');\n// true -> String#at\n// false -> String#codePointAt\nmodule.exports = function (TO_STRING) {\n return function (that, pos) {\n var s = String(defined(that));\n var i = toInteger(pos);\n var l = s.length;\n var a, b;\n if (i < 0 || i >= l) return TO_STRING ? '' : undefined;\n a = s.charCodeAt(i);\n return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n ? TO_STRING ? s.charAt(i) : a\n : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n };\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_string-at.js\n// module id = 40\n// module chunks = 0","'use strict';\nvar LIBRARY = require('./_library');\nvar $export = require('./_export');\nvar redefine = require('./_redefine');\nvar hide = require('./_hide');\nvar Iterators = require('./_iterators');\nvar $iterCreate = require('./_iter-create');\nvar setToStringTag = require('./_set-to-string-tag');\nvar getPrototypeOf = require('./_object-gpo');\nvar ITERATOR = require('./_wks')('iterator');\nvar BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`\nvar FF_ITERATOR = '@@iterator';\nvar KEYS = 'keys';\nvar VALUES = 'values';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {\n $iterCreate(Constructor, NAME, next);\n var getMethod = function (kind) {\n if (!BUGGY && kind in proto) return proto[kind];\n switch (kind) {\n case KEYS: return function keys() { return new Constructor(this, kind); };\n case VALUES: return function values() { return new Constructor(this, kind); };\n } return function entries() { return new Constructor(this, kind); };\n };\n var TAG = NAME + ' Iterator';\n var DEF_VALUES = DEFAULT == VALUES;\n var VALUES_BUG = false;\n var proto = Base.prototype;\n var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];\n var $default = $native || getMethod(DEFAULT);\n var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;\n var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;\n var methods, key, IteratorPrototype;\n // Fix native\n if ($anyNative) {\n IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));\n if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {\n // Set @@toStringTag to native iterators\n setToStringTag(IteratorPrototype, TAG, true);\n // fix for some old engines\n if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') hide(IteratorPrototype, ITERATOR, returnThis);\n }\n }\n // fix Array#{values, @@iterator}.name in V8 / FF\n if (DEF_VALUES && $native && $native.name !== VALUES) {\n VALUES_BUG = true;\n $default = function values() { return $native.call(this); };\n }\n // Define iterator\n if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {\n hide(proto, ITERATOR, $default);\n }\n // Plug for library\n Iterators[NAME] = $default;\n Iterators[TAG] = returnThis;\n if (DEFAULT) {\n methods = {\n values: DEF_VALUES ? $default : getMethod(VALUES),\n keys: IS_SET ? $default : getMethod(KEYS),\n entries: $entries\n };\n if (FORCED) for (key in methods) {\n if (!(key in proto)) redefine(proto, key, methods[key]);\n } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n }\n return methods;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_iter-define.js\n// module id = 41\n// module chunks = 0","module.exports = !require('./_descriptors') && !require('./_fails')(function () {\n return Object.defineProperty(require('./_dom-create')('div'), 'a', { get: function () { return 7; } }).a != 7;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_ie8-dom-define.js\n// module id = 42\n// module chunks = 0","// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function (it, S) {\n if (!isObject(it)) return it;\n var fn, val;\n if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;\n if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;\n if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;\n throw TypeError(\"Can't convert object to primitive value\");\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_to-primitive.js\n// module id = 43\n// module chunks = 0","module.exports = function (it) {\n if (typeof it != 'function') throw TypeError(it + ' is not a function!');\n return it;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_a-function.js\n// module id = 44\n// module chunks = 0","'use strict';\nvar create = require('./_object-create');\nvar descriptor = require('./_property-desc');\nvar setToStringTag = require('./_set-to-string-tag');\nvar IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nrequire('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function () { return this; });\n\nmodule.exports = function (Constructor, NAME, next) {\n Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });\n setToStringTag(Constructor, NAME + ' Iterator');\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_iter-create.js\n// module id = 45\n// module chunks = 0","// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\nvar anObject = require('./_an-object');\nvar dPs = require('./_object-dps');\nvar enumBugKeys = require('./_enum-bug-keys');\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\nvar Empty = function () { /* empty */ };\nvar PROTOTYPE = 'prototype';\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar createDict = function () {\n // Thrash, waste and sodomy: IE GC bug\n var iframe = require('./_dom-create')('iframe');\n var i = enumBugKeys.length;\n var lt = '<';\n var gt = '>';\n var iframeDocument;\n iframe.style.display = 'none';\n require('./_html').appendChild(iframe);\n iframe.src = 'javascript:'; // eslint-disable-line no-script-url\n // createDict = iframe.contentWindow.Object;\n // html.removeChild(iframe);\n iframeDocument = iframe.contentWindow.document;\n iframeDocument.open();\n iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);\n iframeDocument.close();\n createDict = iframeDocument.F;\n while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];\n return createDict();\n};\n\nmodule.exports = Object.create || function create(O, Properties) {\n var result;\n if (O !== null) {\n Empty[PROTOTYPE] = anObject(O);\n result = new Empty();\n Empty[PROTOTYPE] = null;\n // add \"__proto__\" for Object.getPrototypeOf polyfill\n result[IE_PROTO] = O;\n } else result = createDict();\n return Properties === undefined ? result : dPs(result, Properties);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_object-create.js\n// module id = 46\n// module chunks = 0","var dP = require('./_object-dp');\nvar anObject = require('./_an-object');\nvar getKeys = require('./_object-keys');\n\nmodule.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties) {\n anObject(O);\n var keys = getKeys(Properties);\n var length = keys.length;\n var i = 0;\n var P;\n while (length > i) dP.f(O, P = keys[i++], Properties[P]);\n return O;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_object-dps.js\n// module id = 47\n// module chunks = 0","// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys = require('./_object-keys-internal');\nvar enumBugKeys = require('./_enum-bug-keys');\n\nmodule.exports = Object.keys || function keys(O) {\n return $keys(O, enumBugKeys);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_object-keys.js\n// module id = 48\n// module chunks = 0","var has = require('./_has');\nvar toIObject = require('./_to-iobject');\nvar arrayIndexOf = require('./_array-includes')(false);\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\n\nmodule.exports = function (object, names) {\n var O = toIObject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (has(O, key = names[i++])) {\n ~arrayIndexOf(result, key) || result.push(key);\n }\n return result;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_object-keys-internal.js\n// module id = 49\n// module chunks = 0","// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = require('./_cof');\n// eslint-disable-next-line no-prototype-builtins\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {\n return cof(it) == 'String' ? it.split('') : Object(it);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_iobject.js\n// module id = 50\n// module chunks = 0","// false -> Array#indexOf\n// true -> Array#includes\nvar toIObject = require('./_to-iobject');\nvar toLength = require('./_to-length');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nmodule.exports = function (IS_INCLUDES) {\n return function ($this, el, fromIndex) {\n var O = toIObject($this);\n var length = toLength(O.length);\n var index = toAbsoluteIndex(fromIndex, length);\n var value;\n // Array#includes uses SameValueZero equality algorithm\n // eslint-disable-next-line no-self-compare\n if (IS_INCLUDES && el != el) while (length > index) {\n value = O[index++];\n // eslint-disable-next-line no-self-compare\n if (value != value) return true;\n // Array#indexOf ignores holes, Array#includes - not\n } else for (;length > index; index++) if (IS_INCLUDES || index in O) {\n if (O[index] === el) return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_array-includes.js\n// module id = 51\n// module chunks = 0","var toInteger = require('./_to-integer');\nvar max = Math.max;\nvar min = Math.min;\nmodule.exports = function (index, length) {\n index = toInteger(index);\n return index < 0 ? max(index + length, 0) : min(index, length);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_to-absolute-index.js\n// module id = 52\n// module chunks = 0","var document = require('./_global').document;\nmodule.exports = document && document.documentElement;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_html.js\n// module id = 53\n// module chunks = 0","// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\nvar has = require('./_has');\nvar toObject = require('./_to-object');\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\nvar ObjectProto = Object.prototype;\n\nmodule.exports = Object.getPrototypeOf || function (O) {\n O = toObject(O);\n if (has(O, IE_PROTO)) return O[IE_PROTO];\n if (typeof O.constructor == 'function' && O instanceof O.constructor) {\n return O.constructor.prototype;\n } return O instanceof Object ? ObjectProto : null;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_object-gpo.js\n// module id = 54\n// module chunks = 0","'use strict';\nvar ctx = require('./_ctx');\nvar $export = require('./_export');\nvar toObject = require('./_to-object');\nvar call = require('./_iter-call');\nvar isArrayIter = require('./_is-array-iter');\nvar toLength = require('./_to-length');\nvar createProperty = require('./_create-property');\nvar getIterFn = require('./core.get-iterator-method');\n\n$export($export.S + $export.F * !require('./_iter-detect')(function (iter) { Array.from(iter); }), 'Array', {\n // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)\n from: function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {\n var O = toObject(arrayLike);\n var C = typeof this == 'function' ? this : Array;\n var aLen = arguments.length;\n var mapfn = aLen > 1 ? arguments[1] : undefined;\n var mapping = mapfn !== undefined;\n var index = 0;\n var iterFn = getIterFn(O);\n var length, result, step, iterator;\n if (mapping) mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);\n // if object isn't iterable or it's array with default iterator - use simple case\n if (iterFn != undefined && !(C == Array && isArrayIter(iterFn))) {\n for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++) {\n createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);\n }\n } else {\n length = toLength(O.length);\n for (result = new C(length); length > index; index++) {\n createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);\n }\n }\n result.length = index;\n return result;\n }\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/es6.array.from.js\n// module id = 55\n// module chunks = 0","// call something on iterator step with safe closing on error\nvar anObject = require('./_an-object');\nmodule.exports = function (iterator, fn, value, entries) {\n try {\n return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n // 7.4.6 IteratorClose(iterator, completion)\n } catch (e) {\n var ret = iterator['return'];\n if (ret !== undefined) anObject(ret.call(iterator));\n throw e;\n }\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_iter-call.js\n// module id = 56\n// module chunks = 0","// check on default Array iterator\nvar Iterators = require('./_iterators');\nvar ITERATOR = require('./_wks')('iterator');\nvar ArrayProto = Array.prototype;\n\nmodule.exports = function (it) {\n return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_is-array-iter.js\n// module id = 57\n// module chunks = 0","'use strict';\nvar $defineProperty = require('./_object-dp');\nvar createDesc = require('./_property-desc');\n\nmodule.exports = function (object, index, value) {\n if (index in object) $defineProperty.f(object, index, createDesc(0, value));\n else object[index] = value;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_create-property.js\n// module id = 58\n// module chunks = 0","var classof = require('./_classof');\nvar ITERATOR = require('./_wks')('iterator');\nvar Iterators = require('./_iterators');\nmodule.exports = require('./_core').getIteratorMethod = function (it) {\n if (it != undefined) return it[ITERATOR]\n || it['@@iterator']\n || Iterators[classof(it)];\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/core.get-iterator-method.js\n// module id = 59\n// module chunks = 0","// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = require('./_cof');\nvar TAG = require('./_wks')('toStringTag');\n// ES3 wrong here\nvar ARG = cof(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n try {\n return it[key];\n } catch (e) { /* empty */ }\n};\n\nmodule.exports = function (it) {\n var O, T, B;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n // builtinTag case\n : ARG ? cof(O)\n // ES3 arguments fallback\n : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_classof.js\n// module id = 60\n// module chunks = 0","var ITERATOR = require('./_wks')('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n var riter = [7][ITERATOR]();\n riter['return'] = function () { SAFE_CLOSING = true; };\n // eslint-disable-next-line no-throw-literal\n Array.from(riter, function () { throw 2; });\n} catch (e) { /* empty */ }\n\nmodule.exports = function (exec, skipClosing) {\n if (!skipClosing && !SAFE_CLOSING) return false;\n var safe = false;\n try {\n var arr = [7];\n var iter = arr[ITERATOR]();\n iter.next = function () { return { done: safe = true }; };\n arr[ITERATOR] = function () { return iter; };\n exec(arr);\n } catch (e) { /* empty */ }\n return safe;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/core-js/modules/_iter-detect.js\n// module id = 61\n// module chunks = 0","// Polyfill for creating CustomEvents on IE9/10/11\n\n// code pulled from:\n// https://github.com/d4tocchini/customevent-polyfill\n// https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent#Polyfill\n\ntry {\n var ce = new window.CustomEvent('test');\n ce.preventDefault();\n if (ce.defaultPrevented !== true) {\n // IE has problems with .preventDefault() on custom events\n // http://stackoverflow.com/questions/23349191\n throw new Error('Could not prevent default');\n }\n} catch(e) {\n var CustomEvent = function(event, params) {\n var evt, origPrevent;\n params = params || {\n bubbles: false,\n cancelable: false,\n detail: undefined\n };\n\n evt = document.createEvent(\"CustomEvent\");\n evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);\n origPrevent = evt.preventDefault;\n evt.preventDefault = function () {\n origPrevent.call(this);\n try {\n Object.defineProperty(this, 'defaultPrevented', {\n get: function () {\n return true;\n }\n });\n } catch(e) {\n this.defaultPrevented = true;\n }\n };\n return evt;\n };\n\n CustomEvent.prototype = window.Event.prototype;\n window.CustomEvent = CustomEvent; // expose definition to window\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/custom-event-polyfill/custom-event-polyfill.js\n// module id = 62\n// module chunks = 0","import { createStore } from 'redux';\nimport rootReducer from './../reducers/index';\n\nexport default class Store {\n constructor() {\n this._store = createStore(\n rootReducer,\n window.devToolsExtension ?\n window.devToolsExtension() :\n undefined,\n );\n }\n\n /**\n * Subscribe store to function call (wrapped Redux method)\n * @param {Function} onChange Function to trigger when state changes\n * @return\n */\n subscribe(onChange) {\n this._store.subscribe(onChange);\n }\n\n /**\n * Dispatch event to store (wrapped Redux method)\n * @param {Function} action Action function to trigger\n * @return\n */\n dispatch(action) {\n this._store.dispatch(action);\n }\n\n /**\n * Get store object (wrapping Redux method)\n * @return {Object} State\n */\n get state() {\n return this._store.getState();\n }\n\n /**\n * Get items from store\n * @return {Array} Item objects\n */\n get items() {\n return this.state.items;\n }\n\n /**\n * Get active items from store\n * @return {Array} Item objects\n */\n get activeItems() {\n return this.items.filter(item => item.active === true);\n }\n\n /**\n * Get highlighted items from store\n * @return {Array} Item objects\n */\n get highlightedActiveItems() {\n return this.items.filter(item => item.active && item.highlighted);\n }\n\n /**\n * Get choices from store\n * @return {Array} Option objects\n */\n get choices() {\n return this.state.choices;\n }\n\n /**\n * Get active choices from store\n * @return {Array} Option objects\n */\n get activeChoices() {\n const choices = this.choices;\n const values = choices.filter(choice => choice.active === true);\n\n return values;\n }\n\n /**\n * Get selectable choices from store\n * @return {Array} Option objects\n */\n get selectableChoices() {\n return this.choices.filter(choice => choice.disabled !== true);\n }\n\n /**\n * Get choices that can be searched (excluding placeholders)\n * @return {Array} Option objects\n */\n get searchableChoices() {\n return this.selectableChoices.filter(choice => choice.placeholder !== true);\n }\n\n /**\n * Get placeholder choice from store\n * @return {Object} Found placeholder\n */\n get placeholderChoice() {\n return [...this.choices]\n .reverse()\n .find(choice => choice.placeholder === true);\n }\n\n /**\n * Get groups from store\n * @return {Array} Group objects\n */\n get groups() {\n return this.state.groups;\n }\n\n /**\n * Get active groups from store\n * @return {Array} Group objects\n */\n get activeGroups() {\n const groups = this.groups;\n const choices = this.choices;\n\n return groups.filter((group) => {\n const isActive = group.active === true && group.disabled === false;\n const hasActiveOptions = choices.some(choice =>\n choice.active === true && choice.disabled === false,\n );\n return isActive && hasActiveOptions;\n }, []);\n }\n\n /**\n * Get single choice by it's ID\n * @return {Object} Found choice\n */\n getChoiceById(id) {\n if (id) {\n const choices = this.activeChoices;\n const foundChoice = choices.find(choice => choice.id === parseInt(id, 10));\n return foundChoice;\n }\n return false;\n }\n\n /**\n * Get group by group id\n * @param {Number} id Group ID\n * @return {Object} Group data\n */\n getGroupById(id) {\n return this.groups.find(group => group.id === parseInt(id, 10));\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/store/store.js","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nexport default freeGlobal;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/lodash-es/_freeGlobal.js\n// module id = 64\n// module chunks = 0","module.exports = require('./lib/index');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/symbol-observable/index.js\n// module id = 65\n// module chunks = 0","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _ponyfill = require('./ponyfill.js');\n\nvar _ponyfill2 = _interopRequireDefault(_ponyfill);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar root; /* global window */\n\n\nif (typeof self !== 'undefined') {\n root = self;\n} else if (typeof window !== 'undefined') {\n root = window;\n} else if (typeof global !== 'undefined') {\n root = global;\n} else if (typeof module !== 'undefined') {\n root = module;\n} else {\n root = Function('return this')();\n}\n\nvar result = (0, _ponyfill2['default'])(root);\nexports['default'] = result;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/symbol-observable/lib/index.js\n// module id = 66\n// module chunks = 0","module.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/module.js\n// module id = 67\n// module chunks = 0","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n\tvalue: true\n});\nexports['default'] = symbolObservablePonyfill;\nfunction symbolObservablePonyfill(root) {\n\tvar result;\n\tvar _Symbol = root.Symbol;\n\n\tif (typeof _Symbol === 'function') {\n\t\tif (_Symbol.observable) {\n\t\t\tresult = _Symbol.observable;\n\t\t} else {\n\t\t\tresult = _Symbol('observable');\n\t\t\t_Symbol.observable = result;\n\t\t}\n\t} else {\n\t\tresult = '@@observable';\n\t}\n\n\treturn result;\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/symbol-observable/lib/ponyfill.js\n// module id = 68\n// module chunks = 0","import { combineReducers } from 'redux';\nimport items from './items';\nimport groups from './groups';\nimport choices from './choices';\n\nconst appReducer = combineReducers({\n items,\n groups,\n choices,\n});\n\nconst rootReducer = (passedState, action) => {\n let state = passedState;\n // If we are clearing all items, groups and options we reassign\n // state and then pass that state to our proper reducer. This isn't\n // mutating our actual state\n // See: http://stackoverflow.com/a/35641992\n if (action.type === 'CLEAR_ALL') {\n state = undefined;\n }\n\n return appReducer(state, action);\n};\n\nexport default rootReducer;\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/reducers/index.js","export const defaultState = [];\n\nexport default function items(state = defaultState, action) {\n switch (action.type) {\n case 'ADD_ITEM': {\n // Add object to items array\n const newState = [...state, {\n id: action.id,\n choiceId: action.choiceId,\n groupId: action.groupId,\n value: action.value,\n label: action.label,\n active: true,\n highlighted: false,\n customProperties: action.customProperties,\n placeholder: (action.placeholder || false),\n keyCode: null,\n }];\n\n return newState.map((obj) => {\n const item = obj;\n item.highlighted = false;\n return item;\n });\n }\n\n case 'REMOVE_ITEM': {\n // Set item to inactive\n return state.map((obj) => {\n const item = obj;\n if (item.id === action.id) {\n item.active = false;\n }\n return item;\n });\n }\n\n case 'HIGHLIGHT_ITEM': {\n return state.map((obj) => {\n const item = obj;\n if (item.id === action.id) {\n item.highlighted = action.highlighted;\n }\n return item;\n });\n }\n\n default: {\n return state;\n }\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/reducers/items.js","export const defaultState = [];\n\nexport default function groups(state = defaultState, action) {\n switch (action.type) {\n case 'ADD_GROUP': {\n return [...state, {\n id: action.id,\n value: action.value,\n active: action.active,\n disabled: action.disabled,\n }];\n }\n\n case 'CLEAR_CHOICES': {\n return [];\n }\n\n default: {\n return state;\n }\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/reducers/groups.js","export const defaultState = [];\n\nexport default function choices(state = defaultState, action) {\n switch (action.type) {\n case 'ADD_CHOICE': {\n /*\n A disabled choice appears in the choice dropdown but cannot be selected\n A selected choice has been added to the passed input's value (added as an item)\n An active choice appears within the choice dropdown\n */\n return [...state, {\n id: action.id,\n elementId: action.elementId,\n groupId: action.groupId,\n value: action.value,\n label: (action.label || action.value),\n disabled: (action.disabled || false),\n selected: false,\n active: true,\n score: 9999,\n customProperties: action.customProperties,\n placeholder: (action.placeholder || false),\n keyCode: null,\n }];\n }\n\n case 'ADD_ITEM': {\n // If all choices need to be activated\n if (action.activateOptions) {\n return state.map((obj) => {\n const choice = obj;\n choice.active = action.active;\n return choice;\n });\n }\n\n // When an item is added and it has an associated choice,\n // we want to disable it so it can't be chosen again\n if (action.choiceId > -1) {\n return state.map((obj) => {\n const choice = obj;\n if (choice.id === parseInt(action.choiceId, 10)) {\n choice.selected = true;\n }\n return choice;\n });\n }\n\n return state;\n }\n\n case 'REMOVE_ITEM': {\n // When an item is removed and it has an associated choice,\n // we want to re-enable it so it can be chosen again\n if (action.choiceId > -1) {\n return state.map((obj) => {\n const choice = obj;\n if (choice.id === parseInt(action.choiceId, 10)) {\n choice.selected = false;\n }\n return choice;\n });\n }\n\n return state;\n }\n\n case 'FILTER_CHOICES': {\n return state.map((obj) => {\n const choice = obj;\n // Set active state based on whether choice is\n // within filtered results\n choice.active = action.results.some(({ item, score }) => {\n if (item.id === choice.id) {\n choice.score = score;\n return true;\n }\n return false;\n });\n\n return choice;\n });\n }\n\n case 'ACTIVATE_CHOICES': {\n return state.map((obj) => {\n const choice = obj;\n choice.active = action.active;\n return choice;\n });\n }\n\n case 'CLEAR_CHOICES': {\n return defaultState;\n }\n\n default: {\n return state;\n }\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/reducers/choices.js","import Dropdown from './dropdown';\nimport Container from './container';\nimport Input from './input';\nimport List from './list';\nimport WrappedInput from './wrapped-input';\nimport WrappedSelect from './wrapped-select';\n\nexport {\n Dropdown,\n Container,\n Input,\n List,\n WrappedInput,\n WrappedSelect,\n};\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/components/index.js","export default class Dropdown {\n constructor({ element, type, classNames }) {\n Object.assign(this, { element, type, classNames });\n\n this.isActive = false;\n }\n\n /**\n * Determine how far the top of our element is from\n * the top of the window\n * @return {Number} Vertical position\n */\n distanceFromTopWindow() {\n this.dimensions = this.element.getBoundingClientRect();\n this.position = Math.ceil(this.dimensions.top + window.pageYOffset + this.element.offsetHeight);\n return this.position;\n }\n\n /**\n * Find element that matches passed selector\n * @return {HTMLElement}\n */\n getChild(selector) {\n return this.element.querySelector(selector);\n }\n\n /**\n * Show dropdown to user by adding active state class\n * @return {Object} Class instance\n * @public\n */\n show() {\n this.element.classList.add(this.classNames.activeState);\n this.element.setAttribute('aria-expanded', 'true');\n this.isActive = true;\n return this;\n }\n\n /**\n * Hide dropdown from user\n * @return {Object} Class instance\n * @public\n */\n hide() {\n this.element.classList.remove(this.classNames.activeState);\n this.element.setAttribute('aria-expanded', 'false');\n this.isActive = false;\n return this;\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/components/dropdown.js","import { getWindowHeight, wrap } from '../lib/utils';\n\nexport default class Container {\n constructor({ element, type, classNames, position }) {\n Object.assign(this, { element, classNames, type, position });\n\n this.isOpen = false;\n this.isFlipped = false;\n this.isFocussed = false;\n this.isDisabled = false;\n this.isLoading = false;\n\n this._onFocus = this._onFocus.bind(this);\n this._onBlur = this._onBlur.bind(this);\n }\n\n /**\n * Add event listeners\n */\n addEventListeners() {\n this.element.addEventListener('focus', this._onFocus);\n this.element.addEventListener('blur', this._onBlur);\n }\n\n /**\n * Remove event listeners\n */\n\n /** */\n removeEventListeners() {\n this.element.removeEventListener('focus', this._onFocus);\n this.element.removeEventListener('blur', this._onBlur);\n }\n\n /**\n * Determine whether container should be flipped\n * based on passed dropdown position\n * @param {Number} dropdownPos\n * @returns\n */\n shouldFlip(dropdownPos, windowHeight = getWindowHeight()) {\n if (dropdownPos === undefined) {\n return false;\n }\n\n // If flip is enabled and the dropdown bottom position is\n // greater than the window height flip the dropdown.\n let shouldFlip = false;\n if (this.position === 'auto') {\n shouldFlip = dropdownPos >= windowHeight;\n } else if (this.position === 'top') {\n shouldFlip = true;\n }\n\n return shouldFlip;\n }\n\n /**\n * Set active descendant attribute\n * @param {Number} activeDescendant ID of active descendant\n */\n setActiveDescendant(activeDescendantID) {\n this.element.setAttribute('aria-activedescendant', activeDescendantID);\n }\n\n /**\n * Remove active descendant attribute\n */\n removeActiveDescendant() {\n this.element.removeAttribute('aria-activedescendant');\n }\n\n open(dropdownPos) {\n this.element.classList.add(this.classNames.openState);\n this.element.setAttribute('aria-expanded', 'true');\n this.isOpen = true;\n\n if (this.shouldFlip(dropdownPos)) {\n this.element.classList.add(this.classNames.flippedState);\n this.isFlipped = true;\n }\n }\n\n close() {\n this.element.classList.remove(this.classNames.openState);\n this.element.setAttribute('aria-expanded', 'false');\n this.removeActiveDescendant();\n this.isOpen = false;\n\n // A dropdown flips if it does not have space within the page\n if (this.isFlipped) {\n this.element.classList.remove(this.classNames.flippedState);\n this.isFlipped = false;\n }\n }\n\n focus() {\n if (!this.isFocussed) {\n this.element.focus();\n }\n }\n\n addFocusState() {\n this.element.classList.add(this.classNames.focusState);\n }\n\n removeFocusState() {\n this.element.classList.remove(this.classNames.focusState);\n }\n\n /**\n * Remove disabled state\n */\n enable() {\n this.element.classList.remove(this.classNames.disabledState);\n this.element.removeAttribute('aria-disabled');\n if (this.type === 'select-one') {\n this.element.setAttribute('tabindex', '0');\n }\n this.isDisabled = false;\n }\n\n /**\n * Set disabled state\n */\n disable() {\n this.element.classList.add(this.classNames.disabledState);\n this.element.setAttribute('aria-disabled', 'true');\n if (this.type === 'select-one') {\n this.element.setAttribute('tabindex', '-1');\n }\n this.isDisabled = true;\n }\n\n wrap(element) {\n wrap(element, this.element);\n }\n\n unwrap(element) {\n // Move passed element outside this element\n this.element.parentNode.insertBefore(\n element,\n this.element,\n );\n // Remove this element\n this.element.parentNode.removeChild(this.element);\n }\n\n /**\n * Add loading state to element\n */\n addLoadingState() {\n this.element.classList.add(this.classNames.loadingState);\n this.element.setAttribute('aria-busy', 'true');\n this.isLoading = true;\n }\n\n /**\n * Remove loading state from element\n */\n removeLoadingState() {\n this.element.classList.remove(this.classNames.loadingState);\n this.element.removeAttribute('aria-busy');\n this.isLoading = false;\n }\n\n /**\n * Set focussed state\n */\n _onFocus() {\n this.isFocussed = true;\n }\n\n /**\n * Remove blurred state\n */\n _onBlur() {\n this.isFocussed = false;\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/components/container.js","import { calcWidthOfInput } from '../lib/utils';\n\nexport default class Input {\n constructor({ element, type, classNames, placeholderValue }) {\n Object.assign(this, { element, type, classNames, placeholderValue });\n\n this.element = element;\n this.classNames = classNames;\n this.isFocussed = this.element === document.activeElement;\n this.isDisabled = false;\n\n // Bind event listeners\n this._onPaste = this._onPaste.bind(this);\n this._onInput = this._onInput.bind(this);\n this._onFocus = this._onFocus.bind(this);\n this._onBlur = this._onBlur.bind(this);\n }\n\n set placeholder(placeholder) {\n this.element.placeholder = placeholder;\n }\n\n set value(value) {\n this.element.value = value;\n }\n\n get value() {\n return this.element.value;\n }\n\n addEventListeners() {\n this.element.addEventListener('input', this._onInput);\n this.element.addEventListener('paste', this._onPaste);\n this.element.addEventListener('focus', this._onFocus);\n this.element.addEventListener('blur', this._onBlur);\n }\n\n removeEventListeners() {\n this.element.removeEventListener('input', this._onInput);\n this.element.removeEventListener('paste', this._onPaste);\n this.element.removeEventListener('focus', this._onFocus);\n this.element.removeEventListener('blur', this._onBlur);\n }\n\n enable() {\n this.element.removeAttribute('disabled');\n this.isDisabled = false;\n }\n\n disable() {\n this.element.setAttribute('disabled', '');\n this.isDisabled = true;\n }\n\n focus() {\n if (!this.isFocussed) {\n this.element.focus();\n }\n }\n\n blur() {\n if (this.isFocussed) {\n this.element.blur();\n }\n }\n\n /**\n * Set value of input to blank\n * @return {Object} Class instance\n * @public\n */\n clear(setWidth = true) {\n if (this.element.value) {\n this.element.value = '';\n }\n\n if (setWidth) {\n this.setWidth();\n }\n\n return this;\n }\n\n /**\n * Set the correct input width based on placeholder\n * value or input value\n * @return\n */\n setWidth(enforceWidth) {\n if (this._placeholderValue) {\n // If there is a placeholder, we only want to set the width of the input when it is a greater\n // length than 75% of the placeholder. This stops the input jumping around.\n if (\n (this.element.value &&\n this.element.value.length >= (this._placeholderValue.length / 1.25)) ||\n enforceWidth\n ) {\n this.element.style.width = this.calcWidth();\n }\n } else {\n // If there is no placeholder, resize input to contents\n this.element.style.width = this.calcWidth();\n }\n }\n\n calcWidth() {\n return calcWidthOfInput(this.element);\n }\n\n setActiveDescendant(activeDescendantID) {\n this.element.setAttribute('aria-activedescendant', activeDescendantID);\n }\n\n removeActiveDescendant() {\n this.element.removeAttribute('aria-activedescendant');\n }\n\n /**\n * Input event\n * @return\n * @private\n */\n _onInput() {\n if (this.type !== 'select-one') {\n this.setWidth();\n }\n }\n\n /**\n * Paste event\n * @param {Object} e Event\n * @return\n * @private\n */\n _onPaste(e) {\n // Disable pasting into the input if option has been set\n if (e.target === this.element && this.preventPaste) {\n e.preventDefault();\n }\n }\n\n _onFocus() {\n this.isFocussed = true;\n }\n\n _onBlur() {\n this.isFocussed = false;\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/components/input.js","export default class List {\n constructor({ element }) {\n Object.assign(this, { element });\n\n this.scrollPos = this.element.scrollTop;\n this.height = this.element.offsetHeight;\n this.hasChildren = !!this.element.children;\n }\n\n /**\n * Clear List contents\n */\n clear() {\n this.element.innerHTML = '';\n }\n\n /**\n * Scroll to passed position on Y axis\n */\n scrollTo(scrollPos = 0) {\n this.element.scrollTop = scrollPos;\n }\n /**\n * Append node to element\n */\n append(node) {\n this.element.appendChild(node);\n }\n\n /**\n * Find element that matches passed selector\n * @return {HTMLElement}\n */\n getChild(selector) {\n return this.element.querySelector(selector);\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/components/list.js","import WrappedElement from './wrapped-element';\nimport { reduceToValues } from './../lib/utils';\n\nexport default class WrappedInput extends WrappedElement {\n constructor({ element, classNames, delimiter }) {\n super({ element, classNames });\n this.delimiter = delimiter;\n }\n\n set value(items) {\n const itemsFiltered = reduceToValues(items);\n const itemsFilteredString = itemsFiltered.join(this.delimiter);\n\n this.element.setAttribute('value', itemsFilteredString);\n this.element.value = itemsFilteredString;\n }\n\n // @todo figure out why we need this? Perhaps a babel issue\n get value() {\n return super.value;\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/components/wrapped-input.js","import WrappedElement from './wrapped-element';\nimport templates from './../templates';\n\nexport default class WrappedSelect extends WrappedElement {\n constructor({ element, classNames }) {\n super({ element, classNames });\n }\n\n get placeholderOption() {\n return this.element.querySelector('option[placeholder]');\n }\n\n get optionGroups() {\n return Array.from(this.element.getElementsByTagName('OPTGROUP'));\n }\n\n get options() {\n return Array.from(this.element.options);\n }\n\n set options(options) {\n const fragment = document.createDocumentFragment();\n const addOptionToFragment = (data) => {\n // Create a standard select option\n const template = templates.option(data);\n // Append it to fragment\n fragment.appendChild(template);\n };\n\n // Add each list item to list\n options.forEach(optionData => addOptionToFragment(optionData));\n\n this.appendDocFragment(fragment);\n }\n\n appendDocFragment(fragment) {\n this.element.innerHTML = '';\n this.element.appendChild(fragment);\n }\n}\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/components/wrapped-select.js","/*!\n Copyright (c) 2016 Jed Watson.\n Licensed under the MIT License (MIT), see\n http://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg)) {\n\t\t\t\tclasses.push(classNames.apply(null, arg));\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/classnames/index.js\n// module id = 80\n// module chunks = 0","import { ACTION_TYPES } from './../constants';\n\nexport const addChoice = (\n value,\n label,\n id,\n groupId,\n disabled,\n elementId,\n customProperties,\n placeholder,\n keyCode,\n) => ({\n type: ACTION_TYPES.ADD_CHOICE,\n value,\n label,\n id,\n groupId,\n disabled,\n elementId,\n customProperties,\n placeholder,\n keyCode,\n});\n\nexport const filterChoices = results => ({\n type: ACTION_TYPES.FILTER_CHOICES,\n results,\n});\n\nexport const activateChoices = (active = true) => ({\n type: ACTION_TYPES.ACTIVATE_CHOICES,\n active,\n});\n\nexport const clearChoices = () => ({\n type: ACTION_TYPES.CLEAR_CHOICES,\n});\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/actions/choices.js","import { ACTION_TYPES } from './../constants';\n\nexport const addItem = (\n value,\n label,\n id,\n choiceId,\n groupId,\n customProperties,\n placeholder,\n keyCode,\n) => ({\n type: ACTION_TYPES.ADD_ITEM,\n value,\n label,\n id,\n choiceId,\n groupId,\n customProperties,\n placeholder,\n keyCode,\n});\n\nexport const removeItem = (id, choiceId) => ({\n type: ACTION_TYPES.REMOVE_ITEM,\n id,\n choiceId,\n});\n\nexport const highlightItem = (id, highlighted) => ({\n type: ACTION_TYPES.HIGHLIGHT_ITEM,\n id,\n highlighted,\n});\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/actions/items.js","import { ACTION_TYPES } from './../constants';\n\n/* eslint-disable import/prefer-default-export */\nexport const addGroup = (value, id, active, disabled) => ({\n type: ACTION_TYPES.ADD_GROUP,\n value,\n id,\n active,\n disabled,\n});\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/actions/groups.js","/* eslint-disable import/prefer-default-export */\nexport const clearAll = () => ({\n type: 'CLEAR_ALL',\n});\n\n\n\n// WEBPACK FOOTER //\n// src/scripts/src/actions/misc.js"],"mappings":";AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC7DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACVA;AACA;AACA;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;;;;;AAKA;AAAA;AAEA;AAFA;AACA;AAIA;;;;;AAKA;AACA;AACA;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AAOA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AAOA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;AAKA;AAAA;AAAA;AACA;AAKA;;;;;;AAMA;AACA;AACA;AACA;AACA;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AAQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AAQA;AAAA;AAAA;AACA;AACA;;;;;;;AAOA;AAAA;AACA;AAAA;AACA;AACA;AACA;AAHA;AACA;AAKA;AACA;AACA;AACA;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAOA;AACA;AACA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;ACjWA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACLA;AACA;;;;;;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACfA;AACA;AACA;AACA;AACA;;;;;;;ACJA;AACA;AACA;AACA;;;;;;;ACHA;AACA;AACA;AACA;;;;;;;;;;;;;;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AA1BA;AACA;AA4BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AACA;AAAA;AAAA;AACA;AAAA;AAAA;AACA;AACA;AADA;AAGA;AACA;AAzCA;AACA;AA2CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AARA;AACA;AAUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AATA;AACA;AAWA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AATA;AACA;AAWA;;;;;;AC9GA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACLA;AACA;AACA;AACA;AACA;;;;;;;ACJA;AACA;AACA;;;;;;;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACPA;AACA;AACA;AACA;AACA;;;;;;;ACJA;;;;;;;ACAA;AACA;AACA;AACA;AACA;;;;;;;ACJA;;;;;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC9BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACnBA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACLA;AACA;AACA;AACA;AACA;;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACXA;AACA;AACA;AACA;;;;;;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACNA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACRA;AACA;AACA;AACA;AACA;AACA;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC7CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACdA;AACA;AACA;AACA;AACA;AACA;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC7DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;ACpBA;AACA;;;AACA;AACA;AAAA;AAAA;AACA;AADA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAKA;AACA;AACA;AACA;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAEA;AACA;AACA;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAEA;AACA;AACA;AACA;AACA;;;AAEA;AACA;AACA;AACA;AACA;;;AAEA;AACA;AACA;;;AA/DA;AACA;AACA;;;;;;AAbA;;;;;;;;;;;;;;ACFA;AACA;;;AAAA;AACA;;;;;AACA;AACA;AAQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAaA;AACA;AACA;AAGA;AACA;AAAA;AACA;AAAA;AACA;AAOA;AAGA;AACA;AACA;AAKA;AACA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AAOA;AAAA;AACA;AAAA;AACA;AAOA;AAqBA;AACA;AACA;AAYA;AACA;AACA;AACA;AAGA;AASA;AACA;AACA;AACA;AACA;AAKA;AAYA;AACA;AAAA;AACA;AAAA;AACA;AACA;AAQA;AAiBA;AACA;AACA;AACA;AAIA;AAWA;AACA;AACA;AACA;AAIA;AAOA;AACA;AAAA;AACA;AADA;AACA;AAAA;AACA;AAQA;AAKA;AACA;AACA;AAGA;AAvOA;AACA;AAyOA;;;;;;;;;;;;;;;;;;;;AC7OA;AACA;;;AACA;AACA;AAAA;AACA;;;AAAA;AACA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AAAA;AACA;;;;;;;;;AAcA;;;AAGA;AACA;AAAA;AAAA;AACA;AADA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAHA;AAKA;AACA;AACA;AACA;AAFA;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAGA;AACA;AACA;AACA;AACA;AADA;AACA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AAIA;;;;;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAnBA;AAqBA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AACA;AACA;AACA;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;AAOA;AAAA;AACA;AAAA;AACA;AACA;AACA;AAJA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAJA;AAMA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;AAMA;AACA;AACA;AACA;AACA;AAJA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAJA;AACA;AAMA;AACA;AACA;AACA;;;;;;;;AAKA;AAAA;AACA;AAAA;AAAA;AAAA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AAAA;AACA;AAAA;AAAA;AAAA;AACA;AACA;AACA;AACA;;;;;;;;;;AAOA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;AAOA;AAAA;AACA;AAAA;AACA;AAAA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;AAMA;AAAA;AACA;AADA;AACA;AAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;AAOA;AAAA;AACA;AAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;AAOA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;AAMA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;AASA;AAAA;AAAA;AACA;AADA;AACA;AADA;AAAA;AACA;AAAA;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAMA;AACA;AASA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;AAMA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AAIA;;;;;;;;;;;AAQA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AALA;AACA;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;AAOA;AAAA;AACA;AADA;AACA;AAAA;AACA;AAFA;AAAA;AAAA;AAAA;AACA;AAGA;AACA;AACA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AACA;AACA;AACA;AACA;AAtBA;AAu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pBA;AACA;AAsBA;AACA;AACA;AACA;;;;;;;;;AAMA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AA7BA;AACA;AA+BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;AAOA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;AAMA;AAAA;AACA;AADA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AAWA;AAOA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAYA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AANA;AAQA;AACA;AACA;AACA;AACA;AACA;AACA;AALA;AAOA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;AAMA;AACA;AACA;AACA;AACA;AAJA;AAAA;AAAA;AAAA;AAAA;AACA;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAJA;AAMA;AACA;AACA;AACA;AACA;AAHA;AAKA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AAYA;AAQA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAaA;AACA;AASA;AACA;AACA;AACA;;;;;;;;AAKA;AACA;AACA;AACA;AACA;;;;;;;;;;;;AASA;AAAA;AACA;AADA;AAAA;AACA;AAAA;AAGA;AACA;AACA;AACA;AACA;AACA;AAQA;AACA;AACA;AASA;AACA;AACA;AACA;AACA;AAQA;AACA;AACA;AACA;;;;;;;;;;AAOA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AAPA;AAAA;AAAA;AACA;AAOA;AACA;AACA;AACA;;;;;;;;AAKA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;AAGA;AACA;AACA;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAJA;AACA;AAMA;AACA;AACA;AACA;AACA;AAJA;AACA;AAMA;AACA;AACA;AACA;AAHA;AACA;AAKA;AACA;AADA;AACA;AAGA;AACA;AADA;AACA;AAGA;AACA;AACA;AACA;AAHA;AAKA;AACA;AACA;;;;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAEA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAOA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AALA;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AASA;AACA;AACA;AASA;AACA;AACA;AACA;AACA;AAAA;AAAA;AACA;AACA;;;AAEA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AAQA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AACA;;;AAEA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAQA;AACA;AAQA;AACA;AACA;AACA;AACA;AAOA;AACA;AACA;AACA;AAxCA;AACA;AA0CA;AACA;;;AAEA;AAAA;AACA;AAAA;AACA;AACA;AAAA;AAAA;AACA;AACA;AACA;AASA;AACA;;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAcA;AACA;AACA;AAGA;AACA;AACA;AACA;;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAEA;AACA;AACA;AACA;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAGA;AACA;AACA;AACA;AAGA;AACA;AACA;AACA;AACA;AACA;;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AA/GA;AACA;AAEA;AACA;AACA;AACA;AALA;AACA;AAOA;AACA;;;;;;AAu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n+BA;AACA;AAAA;;;;;;ACDA;AACA;AACA;;;;;;;;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACpEA;AACA;AACA;;;;;;;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACXA;AACA;AACA;AACA;;;;;;;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AChBA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACNA;AACA;;;;;;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACpCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;AC3CA;AACA;AAAA;AACA;;;;;;;;;AACA;AACA;AAAA;AACA;AAAA;AAMA;AACA;AACA;;;;;;;;;AAKA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AACA;AACA;AACA;AACA;;;;;;;;;AAsGA;;;;AAIA;AACA;AACA;AACA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AACA;AAAA;AAAA;AACA;;;AAtHA;AACA;AACA;AACA;AACA;;;;;;;AAIA;AACA;AACA;AACA;AACA;;;;;;;AAIA;AACA;AAAA;AAAA;AACA;AACA;AACA;;;;;;;AAIA;AACA;AAAA;AAAA;AACA;AACA;AACA;;;;;;;AAIA;AACA;AACA;AACA;AACA;;;;;;;AAIA;AACA;AACA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;;;;;;;AAIA;AACA;AAAA;AAAA;AACA;AACA;AACA;;;;;;;AAIA;AACA;AAAA;AAAA;AACA;AACA;AACA;;;;;;;AAIA;AACA;AAEA;AAAA;AACA;AACA;AACA;;;;;;;AAIA;AACA;AACA;AACA;AACA;;;;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AAGA;AACA;AACA;;;;;;AAhIA;;;;;;;ACHA;AACA;AACA;AACA;;;;;;;;ACHA;;;;;;;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AC5BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACtBA;AACA;AAAA;AACA;;;AAAA;AACA;;;AAAA;AACA;;;;;AACA;AACA;AACA;AACA;AAHA;AACA;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACtBA;AACA;;;AAHA;AACA;AACA;AAAA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAVA;AACA;AAYA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AACA;AACA;AA9CA;AAgDA;;;;;;;;;;;;ACjDA;AACA;;;AAHA;AACA;AACA;AAAA;AAAA;AACA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AAJA;AAMA;AACA;AACA;AAAA;AACA;AACA;AACA;AACA;AAAA;AACA;AACA;AAhBA;AAkBA;;;;;;;;;;;;ACnBA;AACA;;;AAHA;AACA;AACA;AAAA;AAAA;AACA;AAAA;AACA;AAAA;AACA;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAZA;AAcA;AACA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AACA;AACA;AACA;AACA;AAAA;AACA;AACA;AA/FA;AAiGA;;;;;;;;;;;;;;ACpGA;AACA;;;AAAA;AACA;;;AAAA;AACA;;;AAAA;AACA;;;AAAA;AACA;;;AAAA;AACA;;;;;AAEA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;;;ACbA;AACA;AAAA;AAAA;AAAA;AACA;AADA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AAIA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;;;;;;AAhDA;;;;;;;;;;;;;;;ACAA;AACA;;;AACA;AACA;AAAA;AAAA;AAAA;AAAA;AACA;AADA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AAGA;AACA;AACA;AACA;AACA;AACA;;;;AAIA;AACA;;;AAAA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;AAMA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AAIA;AACA;AACA;AACA;AACA;;;;;;AAGA;AACA;AACA;;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAEA;AACA;AACA;AACA;AACA;;;AAEA;AACA;AACA;;;AAEA;AACA;AACA;AACA;AACA;;;;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAEA;AACA;AACA;;;AAEA;AACA;AACA;AAIA;AACA;AACA;AACA;AACA;;;;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;AAGA;AACA;AACA;AACA;AACA;;;;;;AAGA;AACA;AACA;;;;;;AAhLA;;;;;;;;;;;;;;;ACFA;AACA;;;AACA;AACA;AAAA;AAAA;AAAA;AAAA;AACA;AADA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAaA;AACA;AACA;AACA;AACA;AACA;;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAEA;AACA;AACA;AACA;;;AAEA;AACA;AACA;AACA;;;AAEA;AACA;AACA;AACA;AACA;;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AAAA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AACA;AACA;AACA;AACA;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAEA;AACA;AACA;;;AAEA;AACA;AACA;;;AAEA;AACA;AACA;AACA;AACA;;;;;;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;AAMA;AACA;AACA;AACA;AACA;AACA;;;AAEA;AACA;AACA;;;AAEA;AACA;AACA;;;AAjIA;AACA;AACA;;;AAEA;AACA;AACA;AAEA;AACA;AACA;;;;;;AA1BA;;;;;;;;;;;;;;;;;ACFA;AACA;AAAA;AACA;AADA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;AAGA;AACA;AACA;AACA;AACA;;;;;;AAGA;AAAA;AACA;AAAA;AACA;AACA;;;;;;AAGA;AACA;AACA;AACA;AACA;;;;;;;AAIA;AACA;AACA;;;;;;AAnCA;;;;;;;;;;;;;;;;;ACAA;AACA;;;AAAA;AACA;;;;;;;;;AACA;;;AACA;AAAA;AAAA;AAAA;AACA;AADA;AACA;AADA;AACA;AACA;AAFA;AAGA;AACA;;;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA;AACA;AACA;;;;;;AAjBA;;;;;;;;;;;;;;;ACHA;AACA;;;AAAA;AACA;;;;;;;;;;;AACA;;;AACA;AAAA;AAAA;AACA;AADA;AACA;AADA;AAEA;AACA;;;AA4BA;AACA;AACA;AACA;;;AA9BA;AACA;AACA;;;AAEA;AACA;AACA;;;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AAAA;AACA;AACA;AACA;;;;;;AA9BA;;;;;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;;AC/CA;AACA;AACA;AAAA;AAWA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAVA;AAVA;AACA;AAsBA;AAAA;AACA;AACA;AAFA;AAAA;AACA;AAIA;AAAA;AAAA;AACA;AACA;AAFA;AAAA;AACA;AAIA;AAAA;AACA;AADA;AAAA;;;;;;;;;;;;;;ACnCA;AACA;AACA;AAAA;AAUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AATA;AATA;AACA;AAoBA;AAAA;AACA;AACA;AACA;AAHA;AAAA;AACA;AAKA;AAAA;AACA;AACA;AACA;AAHA;AAAA;;;;;;;;;;;;;;AC7BA;AACA;AACA;AACA;AAAA;AACA;AACA;AACA;AACA;AACA;AALA;AAAA;;;;;;;;;;;;ACHA;AACA;AAAA;AACA;AADA;AAAA;;;;A","sourceRoot":""}
\ No newline at end of file
diff --git a/public/assets/scripts/choices.min.js b/public/assets/scripts/choices.min.js
new file mode 100644
index 0000000..253ce58
--- /dev/null
+++ b/public/assets/scripts/choices.min.js
@@ -0,0 +1,2 @@
+/*! choices.js v3.0.2 | (c) 2018 Josh Johnson | https://github.com/jshjohnson/Choices#readme */
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.Choices=t():e.Choices=t()}("undefined"!=typeof self?self:this,function(){return function(e){function t(i){if(n[i])return n[i].exports;var r=n[i]={i:i,l:!1,exports:{}};return e[i].call(r.exports,r,r.exports,t),r.l=!0,r.exports}var n={};return t.m=e,t.c=n,t.d=function(e,n,i){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:i})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="/public/assets/scripts/",t(t.s=34)}([function(e,t,n){var i=n(26)("wks"),r=n(14),o=n(2).Symbol,s="function"==typeof o;(e.exports=function(e){return i[e]||(i[e]=s&&o[e]||(s?o:r)("Symbol."+e))}).store=i},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var i="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},r=t.generateChars=function(e){for(var t="",n=0;n2&&void 0!==arguments[2]?arguments[2]:1;if(e&&t){var i=e.parentNode.parentNode,r=Array.from(i.querySelectorAll(t));return r[r.indexOf(e)+(n>0?1:-1)]}},t.isScrolledIntoView=function(e,t){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1;if(e){return n>0?t.scrollTop+t.offsetHeight>=e.offsetTop+e.offsetHeight:e.offsetTop>=t.scrollTop}},t.stripHTML=function(e){return e.replace(/&/g,"&").replace(/>/g,"&rt;").replace(/"+a(t)+"");if(i.style.position="absolute",i.style.padding="0",i.style.top="-9999px",i.style.left="-9999px",i.style.width="auto",i.style.whiteSpace="pre",document.body.contains(e)&&window.getComputedStyle){var r=window.getComputedStyle(e);r&&(i.style.fontSize=r.fontSize,i.style.fontFamily=r.fontFamily,i.style.fontWeight=r.fontWeight,i.style.fontStyle=r.fontStyle,i.style.letterSpacing=r.letterSpacing,i.style.textTransform=r.textTransform,i.style.padding=r.padding)}document.body.appendChild(i),t&&i.offsetWidth!==e.offsetWidth&&(n=i.offsetWidth+4),document.body.removeChild(i)}return n+"px"},t.sortByAlpha=function(e,t){var n=(e.label||e.value).toLowerCase(),i=(t.label||t.value).toLowerCase();return ni?1:0},t.sortByScore=function(e,t){return e.score-t.score},t.dispatchEvent=function(e,t){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:null,i=new CustomEvent(t,{detail:n,bubbles:!0,cancelable:!0});return e.dispatchEvent(i)},t.regexFilter=function(e,t){return!(!e||!t)&&new RegExp(t.source,"i").test(e)},t.getWindowHeight=function(){var e=document.body,t=document.documentElement;return Math.max(e.scrollHeight,e.offsetHeight,t.clientHeight,t.scrollHeight,t.offsetHeight)},t.reduceToValues=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"value";return e.reduce(function(e,n){return e.push(n[t]),e},[])},t.isIE11=function(){return!(!navigator.userAgent.match(/Trident/)||!navigator.userAgent.match(/rv[ :]11/))}},function(e,t){var n=e.exports="undefined"!=typeof window&&window.Math==Math?window:"undefined"!=typeof self&&self.Math==Math?self:Function("return this")();"number"==typeof __g&&(__g=n)},function(e,t){var n=e.exports={version:"2.5.6"};"number"==typeof __e&&(__e=n)},function(e,t,n){var i=n(5),r=n(13);e.exports=n(7)?function(e,t,n){return i.f(e,t,r(1,n))}:function(e,t,n){return e[t]=n,e}},function(e,t,n){var i=n(6),r=n(42),o=n(43),s=Object.defineProperty;t.f=n(7)?Object.defineProperty:function(e,t,n){if(i(e),t=o(t,!0),i(n),r)try{return s(e,t,n)}catch(e){}if("get"in n||"set"in n)throw TypeError("Accessors not supported!");return"value"in n&&(e[t]=n.value),e}},function(e,t,n){var i=n(12);e.exports=function(e){if(!i(e))throw TypeError(e+" is not an object!");return e}},function(e,t,n){e.exports=!n(19)(function(){return 7!=Object.defineProperty({},"a",{get:function(){return 7}}).a})},function(e,t){var n={}.hasOwnProperty;e.exports=function(e,t){return n.call(e,t)}},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.SCROLLING_SPEED=t.KEY_CODES=t.ACTION_TYPES=t.EVENTS=t.DEFAULT_CONFIG=t.DEFAULT_CLASSNAMES=void 0;var i=n(1);t.DEFAULT_CLASSNAMES={containerOuter:"choices",containerInner:"choices__inner",input:"choices__input",inputCloned:"choices__input--cloned",list:"choices__list",listItems:"choices__list--multiple",listSingle:"choices__list--single",listDropdown:"choices__list--dropdown",item:"choices__item",itemSelectable:"choices__item--selectable",itemDisabled:"choices__item--disabled",itemChoice:"choices__item--choice",placeholder:"choices__placeholder",group:"choices__group",groupHeading:"choices__heading",button:"choices__button",activeState:"is-active",focusState:"is-focused",openState:"is-open",disabledState:"is-disabled",highlightedState:"is-highlighted",hiddenState:"is-hidden",flippedState:"is-flipped",loadingState:"is-loading",noResults:"has-no-results",noChoices:"has-no-choices"},t.DEFAULT_CONFIG={items:[],choices:[],silent:!1,renderChoiceLimit:-1,maxItemCount:-1,addItems:!0,removeItems:!0,removeItemButton:!1,editItems:!1,duplicateItems:!0,delimiter:",",paste:!0,searchEnabled:!0,searchChoices:!0,searchFloor:1,searchResultLimit:4,searchFields:["label","value"],position:"auto",resetScrollPosition:!0,regexFilter:null,shouldSort:!0,shouldSortItems:!1,placeholder:!0,placeholderValue:null,searchPlaceholderValue:null,prependValue:null,appendValue:null,renderSelectedChoices:"auto",loadingText:"Loading...",noResultsText:"No results found",noChoicesText:"No choices to choose from",itemSelectText:"Press to select",uniqueItemText:"Only unique values can be added.",addItemText:function(e){return'Press Enter to add "'+(0,i.stripHTML)(e)+'"'},maxItemText:function(e){return"Only "+e+" values can be added."},itemComparer:function(e,t){return e===t},fuseOptions:{includeScore:!0},callbackOnInit:null,callbackOnCreateTemplates:null},t.EVENTS={showDropdown:"showDropdown",hideDropdown:"hideDropdown",change:"change",choice:"choice",search:"search",addItem:"addItem",removeItem:"removeItem",highlightItem:"highlightItem"},t.ACTION_TYPES={ADD_CHOICE:"ADD_CHOICE",FILTER_CHOICES:"FILTER_CHOICES",ACTIVATE_CHOICES:"ACTIVATE_CHOICES",CLEAR_CHOICES:"CLEAR_CHOICES",ADD_GROUP:"ADD_GROUP",ADD_ITEM:"ADD_ITEM",REMOVE_ITEM:"REMOVE_ITEM",HIGHLIGHT_ITEM:"HIGHLIGHT_ITEM",CLEAR_ALL:"CLEAR_ALL"},t.KEY_CODES={BACK_KEY:46,DELETE_KEY:8,ENTER_KEY:13,A_KEY:65,ESC_KEY:27,UP_KEY:38,DOWN_KEY:40,PAGE_UP_KEY:33,PAGE_DOWN_KEY:34},t.SCROLLING_SPEED=4},function(e,t){var n=Math.ceil,i=Math.floor;e.exports=function(e){return isNaN(e=+e)?0:(e>0?i:n)(e)}},function(e,t){e.exports=function(e){if(void 0==e)throw TypeError("Can't call method on "+e);return e}},function(e,t){e.exports=function(e){return"object"==typeof e?null!==e:"function"==typeof e}},function(e,t){e.exports=function(e,t){return{enumerable:!(1&e),configurable:!(2&e),writable:!(4&e),value:t}}},function(e,t){var n=0,i=Math.random();e.exports=function(e){return"Symbol(".concat(void 0===e?"":e,")_",(++n+i).toString(36))}},function(e,t){e.exports={}},function(e,t,n){var i=n(26)("keys"),r=n(14);e.exports=function(e){return i[e]||(i[e]=r(e))}},function(e,t){e.exports=!1},function(e,t,n){var i=n(2),r=n(3),o=n(4),s=n(21),a=n(22),c=function(e,t,n){var l,u,h,d,f=e&c.F,p=e&c.G,v=e&c.S,m=e&c.P,g=e&c.B,y=p?i:v?i[t]||(i[t]={}):(i[t]||{}).prototype,_=p?r:r[t]||(r[t]={}),b=_.prototype||(_.prototype={});p&&(n=t);for(l in n)u=!f&&y&&void 0!==y[l],h=(u?y:n)[l],d=g&&u?a(h,i):m&&"function"==typeof h?a(Function.call,h):h,y&&s(y,l,h,e&c.U),_[l]!=h&&o(_,l,d),m&&b[l]!=h&&(b[l]=h)};i.core=r,c.F=1,c.G=2,c.S=4,c.P=8,c.B=16,c.W=32,c.U=64,c.R=128,e.exports=c},function(e,t){e.exports=function(e){try{return!!e()}catch(e){return!0}}},function(e,t,n){var i=n(12),r=n(2).document,o=i(r)&&i(r.createElement);e.exports=function(e){return o?r.createElement(e):{}}},function(e,t,n){var i=n(2),r=n(4),o=n(8),s=n(14)("src"),a=Function.toString,c=(""+a).split("toString");n(3).inspectSource=function(e){return a.call(e)},(e.exports=function(e,t,n,a){var l="function"==typeof n;l&&(o(n,"name")||r(n,"name",t)),e[t]!==n&&(l&&(o(n,s)||r(n,s,e[t]?""+e[t]:c.join(String(t)))),e===i?e[t]=n:a?e[t]?e[t]=n:r(e,t,n):(delete e[t],r(e,t,n)))})(Function.prototype,"toString",function(){return"function"==typeof this&&this[s]||a.call(this)})},function(e,t,n){var i=n(44);e.exports=function(e,t,n){if(i(e),void 0===t)return e;switch(n){case 1:return function(n){return e.call(t,n)};case 2:return function(n,i){return e.call(t,n,i)};case 3:return function(n,i,r){return e.call(t,n,i,r)}}return function(){return e.apply(t,arguments)}}},function(e,t,n){var i=n(50),r=n(11);e.exports=function(e){return i(r(e))}},function(e,t){var n={}.toString;e.exports=function(e){return n.call(e).slice(8,-1)}},function(e,t,n){var i=n(10),r=Math.min;e.exports=function(e){return e>0?r(i(e),9007199254740991):0}},function(e,t,n){var i=n(3),r=n(2),o=r["__core-js_shared__"]||(r["__core-js_shared__"]={});(e.exports=function(e,t){return o[e]||(o[e]=void 0!==t?t:{})})("versions",[]).push({version:i.version,mode:n(17)?"pure":"global",copyright:"© 2018 Denis Pushkarev (zloirock.ru)"})},function(e,t){e.exports="constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf".split(",")},function(e,t,n){var i=n(5).f,r=n(8),o=n(0)("toStringTag");e.exports=function(e,t,n){e&&!r(e=n?e:e.prototype,o)&&i(e,o,{configurable:!0,value:t})}},function(e,t,n){var i=n(11);e.exports=function(e){return Object(i(e))}},function(e,t,n){"use strict";function i(e){var t=C.call(e,w),n=e[w];try{e[w]=void 0;var i=!0}catch(e){}var r=I.call(e);return i&&(t?e[w]=n:delete e[w]),r}function r(e){return A.call(e)}function o(e){return null==e?void 0===e?P:L:D&&D in Object(e)?T(e):x(e)}function s(e,t){return function(n){return e(t(n))}}function a(e){return null!=e&&"object"==typeof e}function c(e){if(!H(e)||j(e)!=V)return!1;var t=F(e);if(null===t)return!0;var n=G.call(t,"constructor")&&t.constructor;return"function"==typeof n&&n instanceof n&&K.call(n)==Y}function l(e,t,n){function i(){p===f&&(p=f.slice())}function r(){return d}function o(e){if("function"!=typeof e)throw new Error("Expected listener to be a function.");var t=!0;return i(),p.push(e),function(){if(t){t=!1,i();var n=p.indexOf(e);p.splice(n,1)}}}function s(e){if(!W(e))throw new Error("Actions must be plain objects. Use custom middleware for async actions.");if(void 0===e.type)throw new Error('Actions may not have an undefined "type" property. Have you misspelled a constant?');if(v)throw new Error("Reducers may not dispatch actions.");try{v=!0,d=h(d,e)}finally{v=!1}for(var t=f=p,n=0;n0&&void 0!==arguments[0]?arguments[0]:{},t=arguments[1];if(s)throw s;for(var i=!1,r={},a=0;a\n \n ')},containerInner:function(e){return(0,s.strToEl)('\n \n ')},itemList:function(e,t){var n,r=(0,o.default)(e.list,(n={},i(n,e.listSingle,t),i(n,e.listItems,!t),n));return(0,s.strToEl)('\n \n ')},placeholder:function(e,t){return(0,s.strToEl)('\n \n '+t+"\n
\n ")},item:function(e,t,n){var r,a=t.active?'aria-selected="true"':"",c=t.disabled?'aria-disabled="true"':"",l=(0,o.default)(e.item,(r={},i(r,e.highlightedState,t.highlighted),i(r,e.itemSelectable,!t.highlighted),i(r,e.placeholder,t.placeholder),r));if(n){var u;return l=(0,o.default)(e.item,(u={},i(u,e.highlightedState,t.highlighted),i(u,e.itemSelectable,!t.disabled),i(u,e.placeholder,t.placeholder),u)),(0,s.strToEl)('\n \n "+t.label+'\x3c!--\n --\x3e\n
\n ")}return(0,s.strToEl)('\n \n "+t.label+"\n
\n ")},choiceList:function(e,t){var n=t?"":'aria-multiselectable="true"';return(0,s.strToEl)('\n \n
\n ")},choiceGroup:function(e,t){var n=t.disabled?'aria-disabled="true"':"",r=(0,o.default)(e.group,i({},e.itemDisabled,t.disabled));return(0,s.strToEl)('\n \n ")},choice:function(e,t,n){var r,a=t.groupId>0?'role="treeitem"':'role="option"',c=(0,o.default)(e.item,e.itemChoice,(r={},i(r,e.itemDisabled,t.disabled),i(r,e.itemSelectable,!t.disabled),i(r,e.placeholder,t.placeholder),r));return(0,s.strToEl)('\n \n "+t.label+"\n
\n ")},input:function(e){var t=(0,o.default)(e.input,e.inputCloned);return(0,s.strToEl)('\n \n ')},dropdown:function(e){var t=(0,o.default)(e.list,e.listDropdown);return(0,s.strToEl)('\n \n
\n ')},notice:function(e,t){var n,r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:"",a=(0,o.default)(e.item,e.itemChoice,(n={},i(n,e.noResults,"no-results"===r),i(n,e.noChoices,"no-choices"===r),n));return(0,s.strToEl)('\n \n '+t+"\n
\n ")},option:function(e){return(0,s.strToEl)('\n \n ")}};t.default=a},function(e,t,n){e.exports=n(35)},function(e,t,n){"use strict";function i(e){return e&&e.__esModule?e:{default:e}}function r(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function o(e){if(Array.isArray(e)){for(var t=0,n=Array(e.length);t0&&void 0!==arguments[0]?arguments[0]:"[data-choice]",n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};if(s(this,e),(0,b.isType)("String",t)){var i=Array.from(document.querySelectorAll(t));if(i.length>1)return this._generateInstances(i,n)}this.config=e._generateConfig(n),["auto","always"].includes(this.config.renderSelectedChoices)||(this.config.renderSelectedChoices="auto"),this._store=new d.default(this.render),this.initialised=!1,this._currentState={},this._prevState={},this._currentValue="",this._isScrollingOnIe=!1,this._wasTap=!0;var r=(0,b.isType)("String",t)?document.querySelector(t):t;if(this._isTextElement="text"===r.type,this._isSelectOneElement="select-one"===r.type,this._isSelectMultipleElement="select-multiple"===r.type,this._isSelectElement=this._isSelectOneElement||this._isSelectMultipleElement,this._isTextElement?this.passedElement=new f.WrappedInput({element:r,classNames:this.config.classNames,delimiter:this.config.delimiter}):this._isSelectElement&&(this.passedElement=new f.WrappedSelect({element:r,classNames:this.config.classNames})),!this.passedElement)throw new Error("Could not wrap passed element");if(!0===this.config.shouldSortItems&&this._isSelectOneElement&&!this.config.silent&&console.warn("shouldSortElements: Type of passed element is 'select-one', falling back to false."),this._highlightPosition=0,this._placeholderValue=this._generatePlaceholderValue(),this._presetChoices=this.config.choices,this._presetItems=this.config.items,this.passedElement.value&&(this._presetItems=this._presetItems.concat(this.passedElement.value.split(this.config.delimiter))),this._baseId=(0,b.generateId)(this.passedElement.element,"choices-"),this._idNames={itemChoice:"item-choice"},this.render=this.render.bind(this),this._onFocus=this._onFocus.bind(this),this._onBlur=this._onBlur.bind(this),this._onKeyUp=this._onKeyUp.bind(this),this._onKeyDown=this._onKeyDown.bind(this),this._onClick=this._onClick.bind(this),this._onTouchMove=this._onTouchMove.bind(this),this._onTouchEnd=this._onTouchEnd.bind(this),this._onMouseDown=this._onMouseDown.bind(this),this._onMouseOver=this._onMouseOver.bind(this),"active"===this.passedElement.element.getAttribute("data-choice"))return!1;this.init()}return c(e,[{key:"init",value:function(){if(!this.initialised){this.initialised=!0,this._createTemplates(),this._createElements(),this._createStructure(),this._store.subscribe(this.render),this.render(),this._addEventListeners();var e=this.config.callbackOnInit;e&&(0,b.isType)("Function",e)&&e.call(this)}}},{key:"destroy",value:function(){this.initialised&&(this._removeEventListeners(),this.passedElement.reveal(),this.containerOuter.unwrap(this.passedElement.element),this._isSelectElement&&(this.passedElement.options=this._presetChoices),this.clearStore(),this.config.templates=null,this.initialised=!1)}},{key:"enable",value:function(){return this.initialised?(this.passedElement.enable(),this.containerOuter.isDisabled&&(this._addEventListeners(),this.input.enable(),this.containerOuter.enable()),this):this}},{key:"disable",value:function(){return this.initialised?(this.passedElement.disable(),this.containerOuter.isDisabled||(this._removeEventListeners(),this.input.disable(),this.containerOuter.disable()),this):this}},{key:"render",value:function(){this._currentState=this._store.state;var e=this._currentState.choices!==this._prevState.choices||this._currentState.groups!==this._prevState.groups||this._currentState.items!==this._prevState.items,t=this._isSelectElement,n=this._currentState.items!==this._prevState.items;e&&(t&&this._renderChoices(),n&&this._renderItems(),this._prevState=this._currentState)}},{key:"highlightItem",value:function(e){var t=!(arguments.length>1&&void 0!==arguments[1])||arguments[1];if(!e)return this;var n=e.id,i=e.groupId,r=void 0===i?-1:i,o=e.value,s=void 0===o?"":o,a=e.label,c=void 0===a?"":a,l=r>=0?this._store.getGroupById(r):null;return this._store.dispatch((0,g.highlightItem)(n,!0)),t&&this.passedElement.triggerEvent(p.EVENTS.highlightItem,{id:n,value:s,label:c,groupValue:l&&l.value?l.value:null}),this}},{key:"unhighlightItem",value:function(e){if(!e)return this;var t=e.id,n=e.groupId,i=void 0===n?-1:n,r=e.value,o=void 0===r?"":r,s=e.label,a=void 0===s?"":s,c=i>=0?this._store.getGroupById(i):null;return this._store.dispatch((0,g.highlightItem)(t,!1)),this.passedElement.triggerEvent(p.EVENTS.highlightItem,{id:t,value:o,label:a,groupValue:c&&c.value?c.value:null}),this}},{key:"highlightAll",value:function(){var e=this;return this._store.items.forEach(function(t){return e.highlightItem(t)}),this}},{key:"unhighlightAll",value:function(){var e=this;return this._store.items.forEach(function(t){return e.unhighlightItem(t)}),this}},{key:"removeActiveItemsByValue",value:function(e){var t=this;return this._store.activeItems.filter(function(t){return t.value===e}).forEach(function(e){return t._removeItem(e)}),this}},{key:"removeActiveItems",value:function(e){var t=this;return this._store.activeItems.filter(function(t){return t.id!==e}).forEach(function(e){return t._removeItem(e)}),this}},{key:"removeHighlightedItems",value:function(){var e=this,t=arguments.length>0&&void 0!==arguments[0]&&arguments[0];return this._store.highlightedActiveItems.forEach(function(n){e._removeItem(n),t&&e._triggerChange(n.value)}),this}},{key:"showDropdown",value:function(e){var t=this;return this.dropdown.isActive?this:(requestAnimationFrame(function(){t.dropdown.show(),t.containerOuter.open(t.dropdown.distanceFromTopWindow()),e&&t.config.searchEnabled&&t.input.focus(),t.passedElement.triggerEvent(p.EVENTS.showDropdown,{})}),this)}},{key:"hideDropdown",value:function(e){var t=this;return this.dropdown.isActive?(requestAnimationFrame(function(){t.dropdown.hide(),t.containerOuter.close(),e&&t.config.searchEnabled&&(t.input.removeActiveDescendant(),t.input.blur()),t.passedElement.triggerEvent(p.EVENTS.hideDropdown,{})}),this):this}},{key:"toggleDropdown",value:function(){return this.dropdown.isActive?this.hideDropdown():this.showDropdown(!0),this}},{key:"getValue",value:function(){var e=arguments.length>0&&void 0!==arguments[0]&&arguments[0],t=this._store.activeItems.reduce(function(t,n){var i=e?n.value:n;return t.push(i),t},[]);return this._isSelectOneElement?t[0]:t}},{key:"setValue",value:function(e){var t=this;return this.initialised?([].concat(o(e)).forEach(function(e){return t._setChoiceOrItem(e)}),this):this}},{key:"setChoiceByValue",value:function(e){var t=this;return!this.initialised||this._isTextElement?this:(((0,b.isType)("Array",e)?e:[e]).forEach(function(e){return t._findAndSelectChoiceByValue(e)}),this)}},{key:"setChoices",value:function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[],t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"",n=this,i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:"",r=arguments.length>3&&void 0!==arguments[3]&&arguments[3];if(!this._isSelectElement||!e.length||!t)return this;r&&this._clearChoices(),this.containerOuter.removeLoadingState();var o=function(e){e.choices?n._addGroup(e,e.id||null,t,i):n._addChoice(e[t],e[i],e.selected,e.disabled,void 0,e.customProperties,e.placeholder)};return e.forEach(o),this}},{key:"clearStore",value:function(){return this._store.dispatch((0,_.clearAll)()),this}},{key:"clearInput",value:function(){var e=!this._isSelectOneElement;return this.input.clear(e),!this._isTextElement&&this.config.searchEnabled&&(this._isSearching=!1,this._store.dispatch((0,m.activateChoices)(!0))),this}},{key:"ajax",value:function(e){var t=this;return this.initialised&&this._isSelectElement&&e?(requestAnimationFrame(function(){return t._handleLoadingState(!0)}),e(this._ajaxCallback()),this):this}},{key:"_createGroupsFragment",value:function(e,t,n){var i=this,r=n||document.createDocumentFragment(),o=function(e){return t.filter(function(t){return i._isSelectOneElement?t.groupId===e.id:t.groupId===e.id&&("always"===i.config.renderSelectedChoices||!t.selected)})};return this.config.shouldSort&&e.sort(this.config.sortFn),e.forEach(function(e){var t=o(e);if(t.length>=1){var n=i._getTemplate("choiceGroup",e);r.appendChild(n),i._createChoicesFragment(t,r,!0)}}),r}},{key:"_createChoicesFragment",value:function(e,t){var n=this,i=arguments.length>2&&void 0!==arguments[2]&&arguments[2],r=t||document.createDocumentFragment(),s=this.config,a=s.renderSelectedChoices,c=s.searchResultLimit,l=s.renderChoiceLimit,u=this._isSearching?b.sortByScore:this.config.sortFn,h=e;"auto"!==a||this._isSelectOneElement||(h=e.filter(function(e){return!e.selected}));var d=h.reduce(function(e,t){return t.placeholder?e.placeholderChoices.push(t):e.normalChoices.push(t),e},{placeholderChoices:[],normalChoices:[]}),f=d.placeholderChoices,p=d.normalChoices;(this.config.shouldSort||this._isSearching)&&p.sort(u);var v=h.length,m=[].concat(o(f),o(p));this._isSearching?v=c:l>0&&!i&&(v=l);for(var g=0;g1&&void 0!==arguments[1]?arguments[1]:null,i=this.config,r=i.shouldSortItems,o=i.sortFn,s=i.removeItemButton,a=n||document.createDocumentFragment();r&&!this._isSelectOneElement&&e.sort(o),this._isTextElement?this.passedElement.value=e:this.passedElement.options=e;var c=function(e){var n=t._getTemplate("item",e,s);a.appendChild(n)};return e.forEach(function(e){return c(e)}),a}},{key:"_triggerChange",value:function(e){void 0!==e&&null!==e&&this.passedElement.triggerEvent(p.EVENTS.change,{value:e})}},{key:"_selectPlaceholderChoice",value:function(){var e=this._store.placeholderChoice;e&&(this._addItem(e.value,e.label,e.id,e.groupId,null,e.placeholder),this._triggerChange(e.value))}},{key:"_handleButtonAction",value:function(e,t){if(e&&t&&this.config.removeItems&&this.config.removeItemButton){var n=t.parentNode.getAttribute("data-id"),i=e.find(function(e){return e.id===parseInt(n,10)});this._removeItem(i),this._triggerChange(i.value),this._isSelectOneElement&&this._selectPlaceholderChoice()}}},{key:"_handleItemAction",value:function(e,t){var n=this,i=arguments.length>2&&void 0!==arguments[2]&&arguments[2];if(e&&t&&this.config.removeItems&&!this._isSelectOneElement){var r=t.getAttribute("data-id");e.forEach(function(e){e.id!==parseInt(r,10)||e.highlighted?!i&&e.highlighted&&n.unhighlightItem(e):n.highlightItem(e)}),this.input.focus()}}},{key:"_handleChoiceAction",value:function(e,t){if(e&&t){var n=t.getAttribute("data-id"),i=this._store.getChoiceById(n),r=e[0]&&e[0].keyCode?e[0].keyCode:null,o=this.dropdown.isActive;if(i.keyCode=r,this.passedElement.triggerEvent(p.EVENTS.choice,{choice:i}),i&&!i.selected&&!i.disabled){this._canAddItem(e,i.value).response&&(this._addItem(i.value,i.label,i.id,i.groupId,i.customProperties,i.placeholder,i.keyCode),this._triggerChange(i.value))}this.clearInput(),o&&this._isSelectOneElement&&(this.hideDropdown(),this.containerOuter.focus())}}},{key:"_handleBackspace",value:function(e){if(this.config.removeItems&&e){var t=e[e.length-1],n=e.some(function(e){return e.highlighted});this.config.editItems&&!n&&t?(this.input.value=t.value,this.input.setWidth(),this._removeItem(t),this._triggerChange(t.value)):(n||this.highlightItem(t,!1),this.removeHighlightedItems(!0))}}},{key:"_handleLoadingState",value:function(){var e=!(arguments.length>0&&void 0!==arguments[0])||arguments[0],t=this.itemList.getChild("."+this.config.classNames.placeholder);e?(this.containerOuter.addLoadingState(),this._isSelectOneElement?t?t.innerHTML=this.config.loadingText:(t=this._getTemplate("placeholder",this.config.loadingText),this.itemList.append(t)):this.input.placeholder=this.config.loadingText):(this.containerOuter.removeLoadingState(),this._isSelectOneElement?t.innerHTML=this._placeholderValue||"":this.input.placeholder=this._placeholderValue||"")}},{key:"_canAddItem",value:function(e,t){var n=!0,i=(0,b.isType)("Function",this.config.addItemText)?this.config.addItemText(t):this.config.addItemText;return(this._isSelectMultipleElement||this._isTextElement)&&this.config.maxItemCount>0&&this.config.maxItemCount<=e.length&&(n=!1,i=(0,b.isType)("Function",this.config.maxItemText)?this.config.maxItemText(this.config.maxItemCount):this.config.maxItemText),this.config.regexFilter&&this._isTextElement&&this.config.addItems&&n&&(n=(0,b.regexFilter)(t,this.config.regexFilter)),!e.some(function(e){return(0,b.isType)("String",t)?e.value===t.trim():e.value===t})||this.config.duplicateItems||this._isSelectOneElement||!n||(n=!1,i=(0,b.isType)("Function",this.config.uniqueItemText)?this.config.uniqueItemText(t):this.config.uniqueItemText),{response:n,notice:i}}},{key:"_ajaxCallback",value:function(){var e=this;return function(t,n,i){if(t&&n){var r=(0,b.isType)("Object",t)?[t]:t;r&&(0,b.isType)("Array",r)&&r.length?(e._handleLoadingState(!1),r.forEach(function(t){if(t.choices){var r=t.id||null;e._addGroup(t,r,n,i)}else e._addChoice(t[n],t[i],t.selected,t.disabled,void 0,t.customProperties,t.placeholder)}),e._isSelectOneElement&&e._selectPlaceholderChoice()):e._handleLoadingState(!1)}}}},{key:"_searchChoices",value:function(e){var t=(0,b.isType)("String",e)?e.trim():e,n=(0,b.isType)("String",this._currentValue)?this._currentValue.trim():this._currentValue;if(t.length<1&&t===n+" ")return 0;var i=this._store.searchableChoices,r=t,o=(0,b.isType)("Array",this.config.searchFields)?this.config.searchFields:[this.config.searchFields],s=Object.assign(this.config.fuseOptions,{keys:o}),a=new u.default(i,s),c=a.search(r);return this._currentValue=t,this._highlightPosition=0,this._isSearching=!0,this._store.dispatch((0,m.filterChoices)(c)),c.length}},{key:"_handleSearch",value:function(e){if(e&&this.input.isFocussed){var t=this._store.choices,n=this.config,i=n.searchFloor,r=n.searchChoices,o=t.some(function(e){return!e.active});if(e&&e.length>=i){var s=r?this._searchChoices(e):0;this.passedElement.triggerEvent(p.EVENTS.search,{value:e,resultCount:s})}else o&&(this._isSearching=!1,this._store.dispatch((0,m.activateChoices)(!0)))}}},{key:"_addEventListeners",value:function(){document.addEventListener("keyup",this._onKeyUp),document.addEventListener("keydown",this._onKeyDown),document.addEventListener("click",this._onClick),document.addEventListener("touchmove",this._onTouchMove),document.addEventListener("touchend",this._onTouchEnd),document.addEventListener("mousedown",this._onMouseDown),document.addEventListener("mouseover",this._onMouseOver),this._isSelectOneElement&&(this.containerOuter.element.addEventListener("focus",this._onFocus),this.containerOuter.element.addEventListener("blur",this._onBlur)),this.input.element.addEventListener("focus",this._onFocus),this.input.element.addEventListener("blur",this._onBlur),this.input.addEventListeners()}},{key:"_removeEventListeners",value:function(){document.removeEventListener("keyup",this._onKeyUp),document.removeEventListener("keydown",this._onKeyDown),document.removeEventListener("click",this._onClick),document.removeEventListener("touchmove",this._onTouchMove),document.removeEventListener("touchend",this._onTouchEnd),document.removeEventListener("mousedown",this._onMouseDown),document.removeEventListener("mouseover",this._onMouseOver),this._isSelectOneElement&&(this.containerOuter.element.removeEventListener("focus",this._onFocus),this.containerOuter.element.removeEventListener("blur",this._onBlur)),this.input.element.removeEventListener("focus",this._onFocus),this.input.element.removeEventListener("blur",this._onBlur),this.input.removeEventListeners()}},{key:"_onKeyDown",value:function(e){var t,n=this;if(e.target===this.input.element||this.containerOuter.element.contains(e.target)){var i=e.target,o=this._store.activeItems,s=this.input.isFocussed,a=this.dropdown.isActive,c=this.itemList.hasChildren,l=String.fromCharCode(e.keyCode),u=p.KEY_CODES.BACK_KEY,h=p.KEY_CODES.DELETE_KEY,d=p.KEY_CODES.ENTER_KEY,f=p.KEY_CODES.A_KEY,v=p.KEY_CODES.ESC_KEY,m=p.KEY_CODES.UP_KEY,g=p.KEY_CODES.DOWN_KEY,y=p.KEY_CODES.PAGE_UP_KEY,_=p.KEY_CODES.PAGE_DOWN_KEY,E=e.ctrlKey||e.metaKey;!this._isTextElement&&/[a-zA-Z0-9-_ ]/.test(l)&&this.showDropdown(!0),this.config.searchEnabled=this.config.searchEnabled;var S=function(){E&&c&&(n.config.searchEnabled=!1,n.config.removeItems&&!n.input.value&&n.input.element===document.activeElement&&n.highlightAll())},O=function(){if(n._isTextElement&&i.value){var t=n.input.value;n._canAddItem(o,t).response&&(n.hideDropdown(),n._addItem(t),n._triggerChange(t),n.clearInput())}if(i.hasAttribute("data-button")&&(n._handleButtonAction(o,i),e.preventDefault()),a){e.preventDefault();var r=n.dropdown.getChild("."+n.config.classNames.highlightedState);r&&(o[0]&&(o[0].keyCode=d),n._handleChoiceAction(o,r))}else n._isSelectOneElement&&(n.showDropdown(!0),e.preventDefault())},C=function(){a&&(n.hideDropdown(),n.containerOuter.focus())},I=function(){if(a||n._isSelectOneElement){n.showDropdown(!0),n.config.searchEnabled=!1;var t=e.keyCode===g||e.keyCode===_?1:-1,i=e.metaKey||e.keyCode===_||e.keyCode===y,r=void 0;if(i)r=t>0?Array.from(n.dropdown.element.querySelectorAll("[data-choice-selectable]")).pop():n.dropdown.element.querySelector("[data-choice-selectable]");else{var o=n.dropdown.element.querySelector("."+n.config.classNames.highlightedState);r=o?(0,b.getAdjacentEl)(o,"[data-choice-selectable]",t):n.dropdown.element.querySelector("[data-choice-selectable]")}r&&((0,b.isScrolledIntoView)(r,n.choiceList.element,t)||n._scrollToChoice(r,t),n._highlightChoice(r)),e.preventDefault()}},w=function(){!s||e.target.value||n._isSelectOneElement||(n._handleBackspace(o),e.preventDefault())},T=(t={},r(t,f,S),r(t,d,O),r(t,v,C),r(t,m,I),r(t,y,I),r(t,g,I),r(t,_,I),r(t,h,w),r(t,u,w),t);T[e.keyCode]&&T[e.keyCode]()}}},{key:"_onKeyUp",value:function(e){if(e.target===this.input.element){var t=this.input.value,n=this._store.activeItems,i=this._canAddItem(n,t);if(this._isTextElement)if(t){if(i.notice){var r=this._getTemplate("notice",i.notice);this.dropdown.element.innerHTML=r.outerHTML}!0===i.response?this.showDropdown():i.notice||this.hideDropdown()}else this.hideDropdown();else{var o=p.KEY_CODES.BACK_KEY,s=p.KEY_CODES.DELETE_KEY;e.keyCode!==o&&e.keyCode!==s||e.target.value?this.config.searchEnabled&&i.response&&this._handleSearch(this.input.value):!this._isTextElement&&this._isSearching&&(this._isSearching=!1,this._store.dispatch((0,m.activateChoices)(!0)))}this.config.searchEnabled=this.config.searchEnabled}}},{key:"_onTouchMove",value:function(){!0===this._wasTap&&(this._wasTap=!1)}},{key:"_onTouchEnd",value:function(e){var t=e.target||e.touches[0].target;!0===this._wasTap&&this.containerOuter.element.contains(t)&&(t!==this.containerOuter.element&&t!==this.containerInner.element||this._isSelectOneElement||(this._isTextElement?this.input.focus():this.showDropdown(!0)),e.stopPropagation()),this._wasTap=!0}},{key:"_onMouseDown",value:function(e){var t=e.target;if(t===this.choiceList&&(0,b.isIE11)()&&(this._isScrollingOnIe=!0),this.containerOuter.element.contains(t)&&t!==this.input.element){var n=this._store.activeItems,i=e.shiftKey,r=(0,b.findAncestorByAttrName)(t,"data-button"),o=(0,b.findAncestorByAttrName)(t,"data-item"),s=(0,b.findAncestorByAttrName)(t,"data-choice");r?this._handleButtonAction(n,r):o?this._handleItemAction(n,o,i):s&&this._handleChoiceAction(n,s),e.preventDefault()}}},{key:"_onMouseOver",value:function(e){(e.target===this.dropdown||this.dropdown.element.contains(e.target))&&e.target.hasAttribute("data-choice")&&this._highlightChoice(e.target)}},{key:"_onClick",value:function(e){var t=e.target,n=this.dropdown.isActive,i=this._store.activeItems;if(this.containerOuter.element.contains(t))n?this._isSelectOneElement&&t!==this.input.element&&!this.dropdown.element.contains(t)&&this.hideDropdown(!0):this._isTextElement?document.activeElement!==this.input.element&&this.input.focus():this.config.searchEnabled?this.showDropdown(!0):(this.showDropdown(),this.containerOuter.focus());else{i.some(function(e){return e.highlighted})&&this.unhighlightAll(),this.containerOuter.removeFocusState(),this.hideDropdown()}}},{key:"_onFocus",value:function(e){var t=this,n=e.target;if(this.containerOuter.element.contains(n)){({text:function(){n===t.input.element&&t.containerOuter.addFocusState()},"select-one":function(){t.containerOuter.addFocusState(),n===t.input.element&&t.showDropdown()},"select-multiple":function(){n===t.input.element&&(t.containerOuter.addFocusState(),t.showDropdown(!0))}})[this.passedElement.element.type]()}}},{key:"_onBlur",value:function(e){var t=this,n=e.target;if(this.containerOuter.element.contains(n)&&!this._isScrollingOnIe){var i=this._store.activeItems,r=i.some(function(e){return e.highlighted});({text:function(){n===t.input.element&&(t.containerOuter.removeFocusState(),r&&t.unhighlightAll(),t.hideDropdown())},"select-one":function(){t.containerOuter.removeFocusState(),(n===t.input.element||n===t.containerOuter.element&&!t.config.searchEnabled)&&t.hideDropdown()},"select-multiple":function(){n===t.input.element&&(t.containerOuter.removeFocusState(),t.hideDropdown(),r&&t.unhighlightAll())}})[this.passedElement.element.type]()}else this._isScrollingOnIe=!1,this.input.element.focus()}},{key:"_scrollToChoice",value:function(e,t){var n=this;if(e){var i=this.choiceList.element.offsetHeight,r=e.offsetHeight,o=e.offsetTop+r,s=this.choiceList.element.scrollTop+i,a=t>0?this.choiceList.element.scrollTop+o-s:e.offsetTop,c=function e(){var i=p.SCROLLING_SPEED,r=n.choiceList.element.scrollTop,o=!1,s=void 0,c=void 0;t>0?(s=(a-r)/i,c=s>1?s:1,n.choiceList.scrollTo(r+c),r1?s:1,n.choiceList.scrollTo(r-c),r>a&&(o=!0)),o&&requestAnimationFrame(function(n){e(n,a,t)})};requestAnimationFrame(function(e){c()})}}},{key:"_highlightChoice",value:function(){var e=this,t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:null,n=Array.from(this.dropdown.element.querySelectorAll("[data-choice-selectable]"));if(n.length){var i=t,r=Array.from(this.dropdown.element.querySelectorAll("."+this.config.classNames.highlightedState)),o=this.dropdown.isActive;r.forEach(function(t){t.classList.remove(e.config.classNames.highlightedState),t.setAttribute("aria-selected","false")}),i?this._highlightPosition=n.indexOf(i):(i=n.length>this._highlightPosition?n[this._highlightPosition]:n[n.length-1])||(i=n[0]),i.classList.add(this.config.classNames.highlightedState),i.setAttribute("aria-selected","true"),o&&(this.input.setActiveDescendant(i.id),this.containerOuter.setActiveDescendant(i.id))}}},{key:"_addItem",value:function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:-1,i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:-1,r=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null,o=arguments.length>5&&void 0!==arguments[5]&&arguments[5],s=arguments.length>6&&void 0!==arguments[6]?arguments[6]:null,a=(0,b.isType)("String",e)?e.trim():e,c=s,l=r,u=this._store.items,h=t||a,d=parseInt(n,10)||-1,f=i>=0?this._store.getGroupById(i):null,v=u?u.length+1:1;return this.config.prependValue&&(a=this.config.prependValue+a.toString()),this.config.appendValue&&(a+=this.config.appendValue.toString()),this._store.dispatch((0,g.addItem)(a,h,v,d,i,r,o,c)),this._isSelectOneElement&&this.removeActiveItems(v),f&&f.value?this.passedElement.triggerEvent(p.EVENTS.addItem,{id:v,value:a,label:h,customProperties:l,groupValue:f.value,keyCode:c}):this.passedElement.triggerEvent(p.EVENTS.addItem,{id:v,value:a,label:h,customProperties:l,keyCode:c}),this}},{key:"_removeItem",value:function(e){if(!e||!(0,b.isType)("Object",e))return this;var t=e.id,n=e.value,i=e.label,r=e.choiceId,o=e.groupId,s=o>=0?this._store.getGroupById(o):null;return this._store.dispatch((0,g.removeItem)(t,r)),s&&s.value?this.passedElement.triggerEvent(p.EVENTS.removeItem,{id:t,value:n,label:i,groupValue:s.value}):this.passedElement.triggerEvent(p.EVENTS.removeItem,{id:t,value:n,label:i}),this}},{key:"_addChoice",value:function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null,n=arguments.length>2&&void 0!==arguments[2]&&arguments[2],i=arguments.length>3&&void 0!==arguments[3]&&arguments[3],r=arguments.length>4&&void 0!==arguments[4]?arguments[4]:-1,o=arguments.length>5&&void 0!==arguments[5]?arguments[5]:null,s=arguments.length>6&&void 0!==arguments[6]&&arguments[6],a=arguments.length>7&&void 0!==arguments[7]?arguments[7]:null;if(void 0!==e&&null!==e){var c=this._store.choices,l=t||e,u=c?c.length+1:1,h=this._baseId+"-"+this._idNames.itemChoice+"-"+u;this._store.dispatch((0,m.addChoice)(e,l,u,r,i,h,o,s,a)),n&&this._addItem(e,l,u,void 0,o,s,a)}}},{key:"_clearChoices",value:function(){this._store.dispatch((0,m.clearChoices)())}},{key:"_addGroup",value:function(e,t){var n=this,i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:"value",r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:"label",o=(0,b.isType)("Object",e)?e.choices:Array.from(e.getElementsByTagName("OPTION")),s=t||Math.floor((new Date).valueOf()*Math.random()),a=!!e.disabled&&e.disabled;if(o){this._store.dispatch((0,y.addGroup)(e.label,s,!0,a));var c=function(e){var t=e.disabled||e.parentNode&&e.parentNode.disabled;n._addChoice(e[i],(0,b.isType)("Object",e)?e[r]:e.innerHTML,e.selected,t,s,e.customProperties,e.placeholder)};o.forEach(c)}else this._store.dispatch((0,y.addGroup)(e.label,e.id,!1,e.disabled))}},{key:"_getTemplate",value:function(e){var t;if(!e)return null;for(var n=this.config.templates,i=this.config.classNames,r=arguments.length,o=Array(r>1?r-1:0),s=1;s=1&&!this._isSearching){var i=t.filter(function(e){return!0===e.placeholder&&-1===e.groupId});i.length>=1&&(n=this._createChoicesFragment(i,n)),n=this._createGroupsFragment(e,t,n)}else t.length>=1&&(n=this._createChoicesFragment(t,n));if(n.childNodes&&n.childNodes.length>0){var r=this._store.activeItems,o=this._canAddItem(r,this.input.value);o.response?(this.choiceList.append(n),this._highlightChoice()):this.choiceList.append(this._getTemplate("notice",o.notice))}else{var s=void 0,a=void 0;this._isSearching?(a=(0,b.isType)("Function",this.config.noResultsText)?this.config.noResultsText():this.config.noResultsText,s=this._getTemplate("notice",a,"no-results")):(a=(0,b.isType)("Function",this.config.noChoicesText)?this.config.noChoicesText():this.config.noChoicesText,s=this._getTemplate("notice",a,"no-choices")),this.choiceList.append(s)}}},{key:"_renderItems",value:function(){var e=this._store.activeItems||[];if(this.itemList.clear(),e.length){var t=this._createItemsFragment(e);t.childNodes&&this.itemList.append(t)}}}],[{key:"_generateConfig",value:function(t){var n=a({},p.DEFAULT_CONFIG,{items:[],choices:[],classNames:p.DEFAULT_CLASSNAMES,sortFn:b.sortByAlpha});return(0,b.extend)(n,e.userDefaults,t)}}]),e}();E.userDefaults={},e.exports=E},function(e,t,n){!function(t,n){e.exports=n()}(0,function(){return function(e){function t(i){if(n[i])return n[i].exports;var r=n[i]={i:i,l:!1,exports:{}};return e[i].call(r.exports,r,r.exports,t),r.l=!0,r.exports}var n={};return t.m=e,t.c=n,t.i=function(e){return e},t.d=function(e,n,i){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:i})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,"a",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=8)}([function(e,t,n){"use strict";e.exports=function(e){return"[object Array]"===Object.prototype.toString.call(e)}},function(e,t,n){"use strict";function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}var r=function(){function e(e,t){for(var n=0;nn)return o(e,this.pattern,i);var r=this.options,a=r.location,c=r.distance,l=r.threshold,u=r.findAllMatches,h=r.minMatchCharLength;return s(e,this.pattern,this.patternAlphabet,{location:a,distance:c,threshold:l,findAllMatches:u,minMatchCharLength:h})}}]),e}();e.exports=c},function(e,t,n){"use strict";var i=n(0),r=function e(t,n,r){if(n){var o=n.indexOf("."),s=n,a=null;-1!==o&&(s=n.slice(0,o),a=n.slice(o+1));var c=t[s];if(null!==c&&void 0!==c)if(a||"string"!=typeof c&&"number"!=typeof c)if(i(c))for(var l=0,u=c.length;l0&&void 0!==arguments[0]?arguments[0]:[],t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1,n=[],i=-1,r=-1,o=0,s=e.length;o=t&&n.push([i,r]),i=-1)}return e[o-1]&&o-i>=t&&n.push([i,o-1]),n}},function(e,t,n){"use strict";e.exports=function(e){for(var t={},n=e.length,i=0;i2&&void 0!==arguments[2]?arguments[2]:/ +/g,r=new RegExp(t.replace(i,"\\$&").replace(n,"|")),o=e.match(r),s=!!o,a=[];if(s)for(var c=0,l=o.length;c=P;M-=1){var N=M-1,F=n[e.charAt(N)];if(F&&(E[N]=1),j[M]=(j[M+1]<<1|1)&F,0!==A&&(j[M]|=(I[M+1]|I[M])<<1|1|I[M+1]),j[M]&k&&(w=i(t,{errors:A,currentLocation:N,expectedLocation:m,distance:l}))<=y){if(y=w,(_=N)<=m)break;P=Math.max(1,2*m-_)}}if(i(t,{errors:A+1,currentLocation:m,expectedLocation:m,distance:l})>y)break;I=j}return{isMatch:_>=0,score:0===w?.001:w,matchedIndices:r(E,v)}}},function(e,t,n){"use strict";function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}var r=function(){function e(e,t){for(var n=0;n0&&void 0!==arguments[0]?arguments[0]:"",t=[];if(this.options.tokenize)for(var n=e.split(this.options.tokenSeparator),i=0,r=n.length;i0&&void 0!==arguments[0]?arguments[0]:[],t=arguments[1],n=this.list,i={},r=[];if("string"==typeof n[0]){for(var o=0,s=n.length;o1)throw new Error("Key weight has to be > 0 and <= 1");f=f.name}else a[f]={weight:1};this._analyze({key:f,value:this.options.getFn(u,f),record:u,index:c},{resultMap:i,results:r,tokenSearchers:e,fullSearcher:t})}return{weights:a,results:r}}},{key:"_analyze",value:function(e,t){var n=e.key,i=e.arrayIndex,r=void 0===i?-1:i,o=e.value,s=e.record,c=e.index,l=t.tokenSearchers,u=void 0===l?[]:l,h=t.fullSearcher,d=void 0===h?[]:h,f=t.resultMap,p=void 0===f?{}:f,v=t.results,m=void 0===v?[]:v;if(void 0!==o&&null!==o){var g=!1,y=-1,_=0;if("string"==typeof o){this._log("\nKey: "+(""===n?"-":n));var b=d.search(o);if(this._log('Full text: "'+o+'", score: '+b.score),this.options.tokenize){for(var E=o.split(this.options.tokenSeparator),S=[],O=0;O-1&&(P=(P+y)/2),this._log("Score average:",P);var D=!this.options.tokenize||!this.options.matchAllTokens||_>=u.length;if(this._log("\nCheck Matches: "+D),(g||b.isMatch)&&D){var j=p[c];j?j.output.push({key:n,arrayIndex:r,value:o,score:P,matchedIndices:b.matchedIndices}):(p[c]={item:s,output:[{key:n,arrayIndex:r,value:o,score:P,matchedIndices:b.matchedIndices}]},m.push(p[c]))}}else if(a(o))for(var M=0,N=o.length;M-1&&(s.arrayIndex=o.arrayIndex),t.matches.push(s)}}}),this.options.includeScore&&n.push(function(e,t){t.score=e.score});for(var i=0,r=e.length;i=t.length?{value:void 0,done:!0}:(e=i(t,n),this._i+=e.length,{value:e,done:!1})})},function(e,t,n){var i=n(10),r=n(11);e.exports=function(e){return function(t,n){var o,s,a=String(r(t)),c=i(n),l=a.length;return c<0||c>=l?e?"":void 0:(o=a.charCodeAt(c),o<55296||o>56319||c+1===l||(s=a.charCodeAt(c+1))<56320||s>57343?e?a.charAt(c):o:e?a.slice(c,c+2):s-56320+(o-55296<<10)+65536)}}},function(e,t,n){"use strict";var i=n(17),r=n(18),o=n(21),s=n(4),a=n(15),c=n(45),l=n(28),u=n(54),h=n(0)("iterator"),d=!([].keys&&"next"in[].keys()),f=function(){return this};e.exports=function(e,t,n,p,v,m,g){c(n,t,p);var y,_,b,E=function(e){if(!d&&e in I)return I[e];switch(e){case"keys":case"values":return function(){return new n(this,e)}}return function(){return new n(this,e)}},S=t+" Iterator",O="values"==v,C=!1,I=e.prototype,w=I[h]||I["@@iterator"]||v&&I[v],T=w||E(v),k=v?O?E("entries"):T:void 0,A="Array"==t?I.entries||w:w;if(A&&(b=u(A.call(new e)))!==Object.prototype&&b.next&&(l(b,S,!0),i||"function"==typeof b[h]||s(b,h,f)),O&&w&&"values"!==w.name&&(C=!0,T=function(){return w.call(this)}),i&&!g||!d&&!C&&I[h]||s(I,h,T),a[t]=T,a[S]=f,v)if(y={values:O?T:E("values"),keys:m?T:E("keys"),entries:k},g)for(_ in y)_ in I||o(I,_,y[_]);else r(r.P+r.F*(d||C),t,y);return y}},function(e,t,n){e.exports=!n(7)&&!n(19)(function(){return 7!=Object.defineProperty(n(20)("div"),"a",{get:function(){return 7}}).a})},function(e,t,n){var i=n(12);e.exports=function(e,t){if(!i(e))return e;var n,r;if(t&&"function"==typeof(n=e.toString)&&!i(r=n.call(e)))return r;if("function"==typeof(n=e.valueOf)&&!i(r=n.call(e)))return r;if(!t&&"function"==typeof(n=e.toString)&&!i(r=n.call(e)))return r;throw TypeError("Can't convert object to primitive value")}},function(e,t){e.exports=function(e){if("function"!=typeof e)throw TypeError(e+" is not a function!");return e}},function(e,t,n){"use strict";var i=n(46),r=n(13),o=n(28),s={};n(4)(s,n(0)("iterator"),function(){return this}),e.exports=function(e,t,n){e.prototype=i(s,{next:r(1,n)}),o(e,t+" Iterator")}},function(e,t,n){var i=n(6),r=n(47),o=n(27),s=n(16)("IE_PROTO"),a=function(){},c=function(){var e,t=n(20)("iframe"),i=o.length;for(t.style.display="none",n(53).appendChild(t),t.src="javascript:",e=t.contentWindow.document,e.open(),e.write("
+
+