vaultify 0.1.0

data/app/assets/javascripts/vaultify/fast.js

@@ -0,0 +1,26 @@
+var fastVar;
+
+
+function fastAPIQuery(query, queryIndex) {
+    fastVar = [];
+    query = query.replace(/[^a-zA-Z\d\s]/g, '');
+    const suggestReturn = queryIndex + "%2Cidroot%2Cauth";
+    let qres = "&query=" + query + "&queryIndex=" + queryIndex + "&queryReturn=" + suggestReturn;
+    qres += "&suggest=autoSubject&rows=20";
+    Rails.ajax({
+        url: "/vaultify/fast.json",
+        async: false,
+        type: "GET",
+        data: qres,
+        success: function (result) {
+            dup = [];
+            result.response.docs.forEach(function (element) {
+                console.log(element);
+                if (!dup.includes(element.auth)) {
+                    dup.push(element.auth);
+                    fastVar.push(JSON.parse('{"text":"' + element.auth + '", "url":"' + element.idroot + '"}'));
+                }
+            });
+        }
+    });
+}

data/app/assets/javascripts/vaultify/horsey.js

@@ -0,0 +1,2917 @@
+(function (f) {
+    if (typeof exports === "object" && typeof module !== "undefined") {
+        module.exports = f()
+    } else if (typeof define === "function" && define.amd) {
+        define([], f)
+    } else {
+        var g;
+        if (typeof window !== "undefined") {
+            g = window
+        } else if (typeof global !== "undefined") {
+            g = global
+        } else if (typeof self !== "undefined") {
+            g = self
+        } else {
+            g = this
+        }
+        g.horsey = f()
+    }
+})(function () {
+    var define, module, exports;
+    return (function e(t, n, r) {
+        function s(o, u) {
+            if (!n[o]) {
+                if (!t[o]) {
+                    var a = typeof require == "function" && require;
+                    if (!u && a) return a(o, !0);
+                    if (i) return i(o, !0);
+                    var f = new Error("Cannot find module '" + o + "'");
+                    throw f.code = "MODULE_NOT_FOUND", f
+                }
+                var l = n[o] = {exports: {}};
+                t[o][0].call(l.exports, function (e) {
+                    var n = t[o][1][e];
+                    return s(n ? n : e)
+                }, l, l.exports, e, t, n, r)
+            }
+            return n[o].exports
+        }
+
+        var i = typeof require == "function" && require;
+        for (var o = 0; o < r.length; o++) s(r[o]);
+        return s
+    })({
+        1: [function (require, module, exports) {
+            'use strict';
+
+            var _hashSum = require('hash-sum');
+
+            var _hashSum2 = _interopRequireDefault(_hashSum);
+
+            var _sell = require('sell');
+
+            var _sell2 = _interopRequireDefault(_sell);
+
+            var _sektor = require('sektor');
+
+            var _sektor2 = _interopRequireDefault(_sektor);
+
+            var _emitter = require('contra/emitter');
+
+            var _emitter2 = _interopRequireDefault(_emitter);
+
+            var _bullseye = require('bullseye');
+
+            var _bullseye2 = _interopRequireDefault(_bullseye);
+
+            var _crossvent = require('crossvent');
+
+            var _crossvent2 = _interopRequireDefault(_crossvent);
+
+            var _fuzzysearch = require('fuzzysearch');
+
+            var _fuzzysearch2 = _interopRequireDefault(_fuzzysearch);
+
+            var _debounce = require('lodash/debounce');
+
+            var _debounce2 = _interopRequireDefault(_debounce);
+
+            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);
+                }
+            }
+
+            var KEY_BACKSPACE = 8;
+            var KEY_ENTER = 13;
+            var KEY_ESC = 27;
+            var KEY_UP = 38;
+            var KEY_DOWN = 40;
+            var KEY_TAB = 9;
+            var doc = document;
+            var docElement = doc.documentElement;
+
+            function horsey(el) {
+                var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+                var setAppends = options.setAppends;
+                var _set = options.set;
+                var filter = options.filter;
+                var source = options.source;
+                var _options$cache = options.cache;
+                var cache = _options$cache === undefined ? {} : _options$cache;
+                var predictNextSearch = options.predictNextSearch;
+                var renderItem = options.renderItem;
+                var renderCategory = options.renderCategory;
+                var blankSearch = options.blankSearch;
+                var appendTo = options.appendTo;
+                var anchor = options.anchor;
+                var debounce = options.debounce;
+
+                var caching = options.cache !== false;
+                if (!source) {
+                    return;
+                }
+
+                var userGetText = options.getText;
+                var userGetValue = options.getValue;
+                var getText = typeof userGetText === 'string' ? function (d) {
+                    return d[userGetText];
+                } : typeof userGetText === 'function' ? userGetText : function (d) {
+                    return d.toString();
+                };
+                var getValue = typeof userGetValue === 'string' ? function (d) {
+                    return d[userGetValue];
+                } : typeof userGetValue === 'function' ? userGetValue : function (d) {
+                    return d;
+                };
+
+                var previousSuggestions = [];
+                var previousSelection = null;
+                var limit = Number(options.limit) || Infinity;
+                var completer = autocomplete(el, {
+                    source: sourceFunction,
+                    limit: limit,
+                    getText: getText,
+                    getValue: getValue,
+                    setAppends: setAppends,
+                    predictNextSearch: predictNextSearch,
+                    renderItem: renderItem,
+                    renderCategory: renderCategory,
+                    appendTo: appendTo,
+                    anchor: anchor,
+                    noMatches: noMatches,
+                    noMatchesText: options.noMatches,
+                    blankSearch: blankSearch,
+                    debounce: debounce,
+                    set: function set(s) {
+                        if (setAppends !== true) {
+                            el.value = '';
+                        }
+                        previousSelection = s;
+                        (_set || completer.defaultSetter)(getText(s), s);
+                        completer.emit('afterSet');
+                    },
+
+                    filter: filter
+                });
+                return completer;
+
+                function noMatches(data) {
+                    if (!options.noMatches) {
+                        return false;
+                    }
+                    return data.query.length;
+                }
+
+                function sourceFunction(data, done) {
+                    var query = data.query;
+                    var limit = data.limit;
+
+                    if (!options.blankSearch && query.length === 0) {
+                        done(null, [], true);
+                        return;
+                    }
+                    if (completer) {
+                        completer.emit('beforeUpdate');
+                    }
+                    var hash = (0, _hashSum2.default)(query); // fast, case insensitive, prevents collisions
+                    if (caching) {
+                        var entry = cache[hash];
+                        if (entry) {
+                            var start = entry.created.getTime();
+                            var duration = cache.duration || 60 * 60 * 24;
+                            var diff = duration * 1000;
+                            var fresh = new Date(start + diff) > new Date();
+                            if (fresh) {
+                                done(null, entry.items.slice());
+                                return;
+                            }
+                        }
+                    }
+                    var sourceData = {
+                        previousSuggestions: previousSuggestions.slice(),
+                        previousSelection: previousSelection,
+                        input: query,
+                        renderItem: renderItem,
+                        renderCategory: renderCategory,
+                        limit: limit
+                    };
+                    if (typeof options.source === 'function') {
+                        options.source(sourceData, sourced);
+                    } else {
+                        sourced(null, options.source);
+                    }
+
+                    function sourced(err, result) {
+                        if (err) {
+                            console.log('Autocomplete source error.', err, el);
+                            done(err, []);
+                        }
+                        var items = Array.isArray(result) ? result : [];
+                        if (caching) {
+                            cache[hash] = {created: new Date(), items: items};
+                        }
+                        previousSuggestions = items;
+                        done(null, items.slice());
+                    }
+                }
+            }
+
+            function autocomplete(el) {
+                var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+
+                var o = options;
+                var parent = o.appendTo || doc.body;
+                var getText = o.getText;
+                var getValue = o.getValue;
+                var form = o.form;
+                var source = o.source;
+                var noMatches = o.noMatches;
+                var noMatchesText = o.noMatchesText;
+                var _o$highlighter = o.highlighter;
+                var highlighter = _o$highlighter === undefined ? true : _o$highlighter;
+                var _o$highlightCompleteW = o.highlightCompleteWords;
+                var highlightCompleteWords = _o$highlightCompleteW === undefined ? true : _o$highlightCompleteW;
+                var _o$renderItem = o.renderItem;
+                var renderItem = _o$renderItem === undefined ? defaultItemRenderer : _o$renderItem;
+                var _o$renderCategory = o.renderCategory;
+                var renderCategory = _o$renderCategory === undefined ? defaultCategoryRenderer : _o$renderCategory;
+                var setAppends = o.setAppends;
+
+                var limit = typeof o.limit === 'number' ? o.limit : Infinity;
+                var userFilter = o.filter || defaultFilter;
+                var userSet = o.set || defaultSetter;
+                var categories = tag('div', 'sey-categories');
+                var container = tag('div', 'sey-container');
+                var deferredFiltering = defer(filtering);
+                var state = {counter: 0, query: null};
+                var categoryMap = Object.create(null);
+                var selection = null;
+                var eye = void 0;
+                var attachment = el;
+                var noneMatch = void 0;
+                var textInput = void 0;
+                var anyInput = void 0;
+                var ranchorleft = void 0;
+                var ranchorright = void 0;
+                var lastPrefix = '';
+                var debounceTime = o.debounce || 300;
+                var debouncedLoading = (0, _debounce2.default)(loading, debounceTime);
+
+                if (o.autoHideOnBlur === void 0) {
+                    o.autoHideOnBlur = true;
+                }
+                if (o.autoHideOnClick === void 0) {
+                    o.autoHideOnClick = true;
+                }
+                if (o.autoShowOnUpDown === void 0) {
+                    o.autoShowOnUpDown = el.tagName === 'INPUT';
+                }
+                if (o.anchor) {
+                    ranchorleft = new RegExp('^' + o.anchor);
+                    ranchorright = new RegExp(o.anchor + '$');
+                }
+
+                var hasItems = false;
+                var api = (0, _emitter2.default)({
+                    anchor: o.anchor,
+                    clear: clear,
+                    show: show,
+                    hide: hide,
+                    toggle: toggle,
+                    destroy: destroy,
+                    refreshPosition: refreshPosition,
+                    appendText: appendText,
+                    appendHTML: appendHTML,
+                    filterAnchoredText: filterAnchoredText,
+                    filterAnchoredHTML: filterAnchoredHTML,
+                    defaultAppendText: appendText,
+                    defaultFilter: defaultFilter,
+                    defaultItemRenderer: defaultItemRenderer,
+                    defaultCategoryRenderer: defaultCategoryRenderer,
+                    defaultSetter: defaultSetter,
+                    retarget: retarget,
+                    attachment: attachment,
+                    source: []
+                });
+
+                retarget(el);
+                container.appendChild(categories);
+                if (noMatches && noMatchesText) {
+                    noneMatch = tag('div', 'sey-empty sey-hide');
+                    text(noneMatch, noMatchesText);
+                    container.appendChild(noneMatch);
+                }
+                parent.appendChild(container);
+                el.setAttribute('autocomplete', 'off');
+
+                if (Array.isArray(source)) {
+                    loaded(source, false);
+                }
+
+                return api;
+
+                function retarget(el) {
+                    inputEvents(true);
+                    attachment = api.attachment = el;
+                    textInput = attachment.tagName === 'INPUT' || attachment.tagName === 'TEXTAREA';
+                    anyInput = textInput || isEditable(attachment);
+                    inputEvents();
+                }
+
+                function refreshPosition() {
+                    if (eye) {
+                        eye.refresh();
+                    }
+                }
+
+                function loading(forceShow) {
+                    if (typeof source !== 'function') {
+                        return;
+                    }
+                    _crossvent2.default.remove(attachment, 'focus', loading);
+                    var query = readInput();
+                    if (query === state.query) {
+                        return;
+                    }
+                    hasItems = false;
+                    state.query = query;
+
+                    var counter = ++state.counter;
+
+                    source({query: query, limit: limit}, sourced);
+
+                    function sourced(err, result, blankQuery) {
+                        if (state.counter !== counter) {
+                            return;
+                        }
+                        loaded(result, forceShow);
+                        if (err || blankQuery) {
+                            hasItems = false;
+                        }
+                    }
+                }
+
+                function loaded(categories, forceShow) {
+                    clear();
+                    hasItems = true;
+                    api.source = [];
+                    categories.forEach(function (cat) {
+                        return cat.list.forEach(function (suggestion) {
+                            return add(suggestion, cat);
+                        });
+                    });
+                    if (forceShow) {
+                        show();
+                    }
+                    filtering();
+                }
+
+                function clear() {
+                    unselect();
+                    while (categories.lastChild) {
+                        categories.removeChild(categories.lastChild);
+                    }
+                    categoryMap = Object.create(null);
+                    hasItems = false;
+                }
+
+                function readInput() {
+                    return (textInput ? el.value : el.innerHTML).trim();
+                }
+
+                function getCategory(data) {
+                    if (!data.id) {
+                        data.id = 'default';
+                    }
+                    if (!categoryMap[data.id]) {
+                        categoryMap[data.id] = createCategory();
+                    }
+                    return categoryMap[data.id];
+
+                    function createCategory() {
+                        var category = tag('div', 'sey-category');
+                        var ul = tag('ul', 'sey-list');
+                        renderCategory(category, data);
+                        category.appendChild(ul);
+                        categories.appendChild(category);
+                        return {data: data, ul: ul};
+                    }
+                }
+
+                function add(suggestion, categoryData) {
+                    var cat = getCategory(categoryData);
+                    var li = tag('li', 'sey-item');
+                    renderItem(li, suggestion);
+                    if (highlighter) {
+                        breakupForHighlighter(li);
+                    }
+                    _crossvent2.default.add(li, 'mouseenter', hoverSuggestion);
+                    _crossvent2.default.add(li, 'click', clickedSuggestion);
+                    _crossvent2.default.add(li, 'horsey-filter', filterItem);
+                    _crossvent2.default.add(li, 'horsey-hide', hideItem);
+                    cat.ul.appendChild(li);
+                    api.source.push(suggestion);
+                    return li;
+
+                    function hoverSuggestion() {
+                        select(li);
+                    }
+
+                    function clickedSuggestion() {
+                        var input = getText(suggestion);
+                        set(suggestion);
+                        hide();
+                        attachment.focus();
+                        lastPrefix = o.predictNextSearch && o.predictNextSearch({
+                            input: input,
+                            source: api.source.slice(),
+                            selection: suggestion
+                        }) || '';
+                        if (lastPrefix) {
+                            el.value = lastPrefix;
+                            el.select();
+                            show();
+                            filtering();
+                        }
+                    }
+
+                    function filterItem() {
+                        var value = readInput();
+                        if (filter(value, suggestion)) {
+                            li.className = li.className.replace(/ sey-hide/g, '');
+                        } else {
+                            _crossvent2.default.fabricate(li, 'horsey-hide');
+                        }
+                    }
+
+                    function hideItem() {
+                        if (!hidden(li)) {
+                            li.className += ' sey-hide';
+                            if (selection === li) {
+                                unselect();
+                            }
+                        }
+                    }
+                }
+
+                function breakupForHighlighter(el) {
+                    getTextChildren(el).forEach(function (el) {
+                        var parent = el.parentElement;
+                        var text = el.textContent || el.nodeValue || '';
+                        if (text.length === 0) {
+                            return;
+                        }
+                        var _iteratorNormalCompletion = true;
+                        var _didIteratorError = false;
+                        var _iteratorError = undefined;
+
+                        try {
+                            for (var _iterator = text[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                                var char = _step.value;
+
+                                parent.insertBefore(spanFor(char), el);
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally {
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return) {
+                                    _iterator.return();
+                                }
+                            } finally {
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+
+                        parent.removeChild(el);
+
+                        function spanFor(char) {
+                            var span = doc.createElement('span');
+                            span.className = 'sey-char';
+                            span.textContent = span.innerText = char;
+                            return span;
+                        }
+                    });
+                }
+
+                function highlight(el, needle) {
+                    var rword = /[\s,._\[\]{}()-]/g;
+                    var words = needle.split(rword).filter(function (w) {
+                        return w.length;
+                    });
+                    var elems = [].concat(_toConsumableArray(el.querySelectorAll('.sey-char')));
+                    var chars = void 0;
+                    var startIndex = 0;
+
+                    balance();
+                    if (highlightCompleteWords) {
+                        whole();
+                    }
+                    fuzzy();
+                    clearRemainder();
+
+                    function balance() {
+                        chars = elems.map(function (el) {
+                            return el.innerText || el.textContent;
+                        });
+                    }
+
+                    function whole() {
+                        var _iteratorNormalCompletion2 = true;
+                        var _didIteratorError2 = false;
+                        var _iteratorError2 = undefined;
+
+                        try {
+                            for (var _iterator2 = words[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+                                var word = _step2.value;
+
+                                var tempIndex = startIndex;
+                                retry: while (tempIndex !== -1) {
+                                    var init = true;
+                                    var prevIndex = tempIndex;
+                                    var _iteratorNormalCompletion3 = true;
+                                    var _didIteratorError3 = false;
+                                    var _iteratorError3 = undefined;
+
+                                    try {
+                                        for (var _iterator3 = word[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+                                            var char = _step3.value;
+
+                                            var i = chars.indexOf(char, prevIndex + 1);
+                                            var fail = i === -1 || !init && prevIndex + 1 !== i;
+                                            if (init) {
+                                                init = false;
+                                                tempIndex = i;
+                                            }
+                                            if (fail) {
+                                                continue retry;
+                                            }
+                                            prevIndex = i;
+                                        }
+                                    } catch (err) {
+                                        _didIteratorError3 = true;
+                                        _iteratorError3 = err;
+                                    } finally {
+                                        try {
+                                            if (!_iteratorNormalCompletion3 && _iterator3.return) {
+                                                _iterator3.return();
+                                            }
+                                        } finally {
+                                            if (_didIteratorError3) {
+                                                throw _iteratorError3;
+                                            }
+                                        }
+                                    }
+
+                                    var _iteratorNormalCompletion4 = true;
+                                    var _didIteratorError4 = false;
+                                    var _iteratorError4 = undefined;
+
+                                    try {
+                                        for (var _iterator4 = elems.splice(tempIndex, 1 + prevIndex - tempIndex)[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+                                            var _el = _step4.value;
+
+                                            on(_el);
+                                        }
+                                    } catch (err) {
+                                        _didIteratorError4 = true;
+                                        _iteratorError4 = err;
+                                    } finally {
+                                        try {
+                                            if (!_iteratorNormalCompletion4 && _iterator4.return) {
+                                                _iterator4.return();
+                                            }
+                                        } finally {
+                                            if (_didIteratorError4) {
+                                                throw _iteratorError4;
+                                            }
+                                        }
+                                    }
+
+                                    balance();
+                                    needle = needle.replace(word, '');
+                                    break;
+                                }
+                            }
+                        } catch (err) {
+                            _didIteratorError2 = true;
+                            _iteratorError2 = err;
+                        } finally {
+                            try {
+                                if (!_iteratorNormalCompletion2 && _iterator2.return) {
+                                    _iterator2.return();
+                                }
+                            } finally {
+                                if (_didIteratorError2) {
+                                    throw _iteratorError2;
+                                }
+                            }
+                        }
+                    }
+
+                    function fuzzy() {
+                        var _iteratorNormalCompletion5 = true;
+                        var _didIteratorError5 = false;
+                        var _iteratorError5 = undefined;
+
+                        try {
+                            for (var _iterator5 = needle[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+                                var input = _step5.value;
+
+                                while (elems.length) {
+                                    var _el2 = elems.shift();
+                                    if ((_el2.innerText || _el2.textContent) === input) {
+                                        on(_el2);
+                                        break;
+                                    } else {
+                                        off(_el2);
+                                    }
+                                }
+                            }
+                        } catch (err) {
+                            _didIteratorError5 = true;
+                            _iteratorError5 = err;
+                        } finally {
+                            try {
+                                if (!_iteratorNormalCompletion5 && _iterator5.return) {
+                                    _iterator5.return();
+                                }
+                            } finally {
+                                if (_didIteratorError5) {
+                                    throw _iteratorError5;
+                                }
+                            }
+                        }
+                    }
+
+                    function clearRemainder() {
+                        while (elems.length) {
+                            off(elems.shift());
+                        }
+                    }
+
+                    function on(ch) {
+                        ch.classList.add('sey-char-highlight');
+                    }
+
+                    function off(ch) {
+                        ch.classList.remove('sey-char-highlight');
+                    }
+                }
+
+                function getTextChildren(el) {
+                    var texts = [];
+                    var walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT, null, false);
+                    var node = void 0;
+                    while (node = walker.nextNode()) {
+                        texts.push(node);
+                    }
+                    return texts;
+                }
+
+                function set(value) {
+                    if (o.anchor) {
+                        return (isText() ? api.appendText : api.appendHTML)(getValue(value));
+                    }
+                    userSet(value);
+                }
+
+                function filter(value, suggestion) {
+                    if (o.anchor) {
+                        var il = (isText() ? api.filterAnchoredText : api.filterAnchoredHTML)(value, suggestion);
+                        return il ? userFilter(il.input, il.suggestion) : false;
+                    }
+                    return userFilter(value, suggestion);
+                }
+
+                function isText() {
+                    return isInput(attachment);
+                }
+
+                function visible() {
+                    return container.className.indexOf('sey-show') !== -1;
+                }
+
+                function hidden(li) {
+                    return li.className.indexOf('sey-hide') !== -1;
+                }
+
+                function show() {
+                    eye.refresh();
+                    if (!visible()) {
+                        container.className += ' sey-show';
+                        _crossvent2.default.fabricate(attachment, 'horsey-show');
+                    }
+                }
+
+                function toggler(e) {
+                    var left = e.which === 1 && !e.metaKey && !e.ctrlKey;
+                    if (left === false) {
+                        return; // we only care about honest to god left-clicks
+                    }
+                    toggle();
+                }
+
+                function toggle() {
+                    if (!visible()) {
+                        show();
+                    } else {
+                        hide();
+                    }
+                }
+
+                function select(li) {
+                    unselect();
+                    if (li) {
+                        selection = li;
+                        selection.className += ' sey-selected';
+                    }
+                }
+
+                function unselect() {
+                    if (selection) {
+                        selection.className = selection.className.replace(/ sey-selected/g, '');
+                        selection = null;
+                    }
+                }
+
+                function move(up, moves) {
+                    var total = api.source.length;
+                    if (total === 0) {
+                        return;
+                    }
+                    if (moves > total) {
+                        unselect();
+                        return;
+                    }
+                    var cat = findCategory(selection) || categories.firstChild;
+                    var first = up ? 'lastChild' : 'firstChild';
+                    var last = up ? 'firstChild' : 'lastChild';
+                    var next = up ? 'previousSibling' : 'nextSibling';
+                    var prev = up ? 'nextSibling' : 'previousSibling';
+                    var li = findNext();
+                    select(li);
+
+                    if (hidden(li)) {
+                        move(up, moves ? moves + 1 : 1);
+                    }
+
+                    function findCategory(el) {
+                        while (el) {
+                            if (_sektor2.default.matchesSelector(el.parentElement, '.sey-category')) {
+                                return el.parentElement;
+                            }
+                            el = el.parentElement;
+                        }
+                        return null;
+                    }
+
+                    function findNext() {
+                        if (selection) {
+                            if (selection[next]) {
+                                return selection[next];
+                            }
+                            if (cat[next] && findList(cat[next])[first]) {
+                                return findList(cat[next])[first];
+                            }
+                        }
+                        return findList(categories[first])[first];
+                    }
+                }
+
+                function hide() {
+                    eye.sleep();
+                    container.className = container.className.replace(/ sey-show/g, '');
+                    unselect();
+                    _crossvent2.default.fabricate(attachment, 'horsey-hide');
+                    if (el.value === lastPrefix) {
+                        el.value = '';
+                    }
+                }
+
+                function keydown(e) {
+                    var shown = visible();
+                    var which = e.which || e.keyCode;
+                    if (which === KEY_DOWN) {
+                        if (anyInput && o.autoShowOnUpDown) {
+                            show();
+                        }
+                        if (shown) {
+                            move();
+                            stop(e);
+                        }
+                    } else if (which === KEY_UP) {
+                        if (anyInput && o.autoShowOnUpDown) {
+                            show();
+                        }
+                        if (shown) {
+                            move(true);
+                            stop(e);
+                        }
+                    } else if (which === KEY_BACKSPACE) {
+                        if (anyInput && o.autoShowOnUpDown) {
+                            show();
+                        }
+                    } else if (shown) {
+                        if (which === KEY_ENTER) {
+                            if (selection) {
+                                _crossvent2.default.fabricate(selection, 'click');
+                            } else {
+                                hide();
+                            }
+                            stop(e);
+                        } else if (which === KEY_ESC) {
+                            hide();
+                            stop(e);
+                        }
+                    }
+                }
+
+                function stop(e) {
+                    e.stopPropagation();
+                    e.preventDefault();
+                }
+
+                function showNoResults() {
+                    if (noneMatch) {
+                        noneMatch.classList.remove('sey-hide');
+                    }
+                }
+
+                function hideNoResults() {
+                    if (noneMatch) {
+                        noneMatch.classList.add('sey-hide');
+                    }
+                }
+
+                function filtering() {
+                    if (!visible()) {
+                        return;
+                    }
+                    debouncedLoading(true);
+                    _crossvent2.default.fabricate(attachment, 'horsey-filter');
+                    var value = readInput();
+                    if (!o.blankSearch && !value) {
+                        hide();
+                        return;
+                    }
+                    var nomatch = noMatches({query: value});
+                    var count = walkCategories();
+                    if (count === 0 && nomatch && hasItems) {
+                        showNoResults();
+                    } else {
+                        hideNoResults();
+                    }
+                    if (!selection) {
+                        move();
+                    }
+                    if (!selection && !nomatch) {
+                        hide();
+                    }
+
+                    function walkCategories() {
+                        var category = categories.firstChild;
+                        var count = 0;
+                        while (category) {
+                            var list = findList(category);
+                            var partial = walkCategory(list);
+                            if (partial === 0) {
+                                category.classList.add('sey-hide');
+                            } else {
+                                category.classList.remove('sey-hide');
+                            }
+                            count += partial;
+                            category = category.nextSibling;
+                        }
+                        return count;
+                    }
+
+                    function walkCategory(ul) {
+                        var li = ul.firstChild;
+                        var count = 0;
+                        while (li) {
+                            if (count >= limit) {
+                                _crossvent2.default.fabricate(li, 'horsey-hide');
+                            } else {
+                                _crossvent2.default.fabricate(li, 'horsey-filter');
+                                if (li.className.indexOf('sey-hide') === -1) {
+                                    count++;
+                                    if (highlighter) {
+                                        highlight(li, value);
+                                    }
+                                }
+                            }
+                            li = li.nextSibling;
+                        }
+                        return count;
+                    }
+                }
+
+                function deferredFilteringNoEnter(e) {
+                    var which = e.which || e.keyCode;
+                    if (which === KEY_ENTER) {
+                        return;
+                    }
+                    deferredFiltering();
+                }
+
+                function deferredShow(e) {
+                    var which = e.which || e.keyCode;
+                    if (which === KEY_ENTER || which === KEY_TAB) {
+                        return;
+                    }
+                    setTimeout(show, 0);
+                }
+
+                function autocompleteEventTarget(e) {
+                    var target = e.target;
+                    if (target === attachment) {
+                        return true;
+                    }
+                    while (target) {
+                        if (target === container || target === attachment) {
+                            return true;
+                        }
+                        target = target.parentNode;
+                    }
+                }
+
+                function hideOnBlur(e) {
+                    var which = e.which || e.keyCode;
+                    if (which === KEY_TAB) {
+                        hide();
+                    }
+                }
+
+                function hideOnClick(e) {
+                    if (autocompleteEventTarget(e)) {
+                        return;
+                    }
+                    hide();
+                }
+
+                function inputEvents(remove) {
+                    var op = remove ? 'remove' : 'add';
+                    if (eye) {
+                        eye.destroy();
+                        eye = null;
+                    }
+                    if (!remove) {
+                        eye = (0, _bullseye2.default)(container, attachment, {
+                            caret: anyInput && attachment.tagName !== 'INPUT',
+                            context: o.appendTo
+                        });
+                        if (!visible()) {
+                            eye.sleep();
+                        }
+                    }
+                    if (remove || anyInput && doc.activeElement !== attachment) {
+                        _crossvent2.default[op](attachment, 'focus', loading);
+                    } else {
+                        loading();
+                    }
+                    if (anyInput) {
+                        _crossvent2.default[op](attachment, 'keypress', deferredShow);
+                        _crossvent2.default[op](attachment, 'keypress', deferredFiltering);
+                        _crossvent2.default[op](attachment, 'keydown', deferredFilteringNoEnter);
+                        _crossvent2.default[op](attachment, 'paste', deferredFiltering);
+                        _crossvent2.default[op](attachment, 'keydown', keydown);
+                        if (o.autoHideOnBlur) {
+                            _crossvent2.default[op](attachment, 'keydown', hideOnBlur);
+                        }
+                    } else {
+                        _crossvent2.default[op](attachment, 'click', toggler);
+                        _crossvent2.default[op](docElement, 'keydown', keydown);
+                    }
+                    if (o.autoHideOnClick) {
+                        _crossvent2.default[op](doc, 'click', hideOnClick);
+                    }
+                    if (form) {
+                        _crossvent2.default[op](form, 'submit', hide);
+                    }
+                }
+
+                function destroy() {
+                    inputEvents(true);
+                    if (parent.contains(container)) {
+                        parent.removeChild(container);
+                    }
+                }
+
+                function defaultSetter(value) {
+                    if (textInput) {
+                        if (setAppends === true) {
+                            el.value += ' ' + value;
+                        } else {
+                            el.value = value;
+                        }
+                    } else {
+                        if (setAppends === true) {
+                            el.innerHTML += ' ' + value;
+                        } else {
+                            el.innerHTML = value;
+                        }
+                    }
+                }
+
+                function defaultItemRenderer(li, suggestion) {
+                    text(li, getText(suggestion));
+                }
+
+                function defaultCategoryRenderer(div, data) {
+                    if (data.id !== 'default') {
+                        var id = tag('div', 'sey-category-id');
+                        div.appendChild(id);
+                        text(id, data.id);
+                    }
+                }
+
+                function defaultFilter(q, suggestion) {
+                    var needle = q.toLowerCase();
+                    var text = getText(suggestion) || '';
+                    if ((0, _fuzzysearch2.default)(needle, text.toLowerCase())) {
+                        return true;
+                    }
+                    var value = getValue(suggestion) || '';
+                    if (typeof value !== 'string') {
+                        return false;
+                    }
+                    return (0, _fuzzysearch2.default)(needle, value.toLowerCase());
+                }
+
+                function loopbackToAnchor(text, p) {
+                    var result = '';
+                    var anchored = false;
+                    var start = p.start;
+                    while (anchored === false && start >= 0) {
+                        result = text.substr(start - 1, p.start - start + 1);
+                        anchored = ranchorleft.test(result);
+                        start--;
+                    }
+                    return {
+                        text: anchored ? result : null,
+                        start: start
+                    };
+                }
+
+                function filterAnchoredText(q, suggestion) {
+                    var position = (0, _sell2.default)(el);
+                    var input = loopbackToAnchor(q, position).text;
+                    if (input) {
+                        return {input: input, suggestion: suggestion};
+                    }
+                }
+
+                function appendText(value) {
+                    var current = el.value;
+                    var position = (0, _sell2.default)(el);
+                    var input = loopbackToAnchor(current, position);
+                    var left = current.substr(0, input.start);
+                    var right = current.substr(input.start + input.text.length + (position.end - position.start));
+                    var before = left + value + ' ';
+
+                    el.value = before + right;
+                    (0, _sell2.default)(el, {start: before.length, end: before.length});
+                }
+
+                function filterAnchoredHTML() {
+                    throw new Error('Anchoring in editable elements is disabled by default.');
+                }
+
+                function appendHTML() {
+                    throw new Error('Anchoring in editable elements is disabled by default.');
+                }
+
+                function findList(category) {
+                    return (0, _sektor2.default)('.sey-list', category)[0];
+                }
+            }
+
+            function isInput(el) {
+                return el.tagName === 'INPUT' || el.tagName === 'TEXTAREA';
+            }
+
+            function tag(type, className) {
+                var el = doc.createElement(type);
+                el.className = className;
+                return el;
+            }
+
+            function defer(fn) {
+                return function () {
+                    setTimeout(fn, 0);
+                };
+            }
+
+            function text(el, value) {
+                el.innerText = el.textContent = value;
+            }
+
+            function isEditable(el) {
+                var value = el.getAttribute('contentEditable');
+                if (value === 'false') {
+                    return false;
+                }
+                if (value === 'true') {
+                    return true;
+                }
+                if (el.parentElement) {
+                    return isEditable(el.parentElement);
+                }
+                return false;
+            }
+
+            module.exports = horsey;
+
+        }, {
+            "bullseye": 3,
+            "contra/emitter": 7,
+            "crossvent": 8,
+            "fuzzysearch": 11,
+            "hash-sum": 12,
+            "lodash/debounce": 13,
+            "sektor": 20,
+            "sell": 29
+        }],
+        2: [function (require, module, exports) {
+            module.exports = function atoa(a, n) {
+                return Array.prototype.slice.call(a, n);
+            }
+
+        }, {}],
+        3: [function (require, module, exports) {
+            'use strict';
+
+            var crossvent = require('crossvent');
+            var throttle = require('./throttle');
+            var tailormade = require('./tailormade');
+
+            function bullseye(el, target, options) {
+                var o = options;
+                var domTarget = target && target.tagName;
+
+                if (!domTarget && arguments.length === 2) {
+                    o = target;
+                }
+                if (!domTarget) {
+                    target = el;
+                }
+                if (!o) {
+                    o = {};
+                }
+
+                var destroyed = false;
+                var throttledWrite = throttle(write, 30);
+                var tailorOptions = {update: o.autoupdateToCaret !== false && update};
+                var tailor = o.caret && tailormade(target, tailorOptions);
+
+                write();
+
+                if (o.tracking !== false) {
+                    crossvent.add(window, 'resize', throttledWrite);
+                }
+
+                return {
+                    read: readNull,
+                    refresh: write,
+                    destroy: destroy,
+                    sleep: sleep
+                };
+
+                function sleep() {
+                    tailorOptions.sleeping = true;
+                }
+
+                function readNull() {
+                    return read();
+                }
+
+                function read(readings) {
+                    var bounds = target.getBoundingClientRect();
+                    var scrollTop = document.body.scrollTop || document.documentElement.scrollTop;
+                    if (tailor) {
+                        readings = tailor.read();
+                        return {
+                            x: (readings.absolute ? 0 : bounds.left) + readings.x,
+                            y: (readings.absolute ? 0 : bounds.top) + scrollTop + readings.y + 20
+                        };
+                    }
+                    return {
+                        x: bounds.left,
+                        y: bounds.top + scrollTop
+                    };
+                }
+
+                function update(readings) {
+                    write(readings);
+                }
+
+                function write(readings) {
+                    if (destroyed) {
+                        throw new Error('Bullseye can\'t refresh after being destroyed. Create another instance instead.');
+                    }
+                    if (tailor && !readings) {
+                        tailorOptions.sleeping = false;
+                        tailor.refresh();
+                        return;
+                    }
+                    var p = read(readings);
+                    if (!tailor && target !== el) {
+                        p.y += target.offsetHeight;
+                    }
+                    var context = o.context;
+                    el.style.left = p.x + 'px';
+                    el.style.top = (context ? context.offsetHeight : p.y) + 'px';
+                }
+
+                function destroy() {
+                    if (tailor) {
+                        tailor.destroy();
+                    }
+                    crossvent.remove(window, 'resize', throttledWrite);
+                    destroyed = true;
+                }
+            }
+
+            module.exports = bullseye;
+
+        }, {"./tailormade": 4, "./throttle": 5, "crossvent": 8}],
+        4: [function (require, module, exports) {
+            (function (global) {
+                'use strict';
+
+                var sell = require('sell');
+                var crossvent = require('crossvent');
+                var seleccion = require('seleccion');
+                var throttle = require('./throttle');
+                var getSelection = seleccion.get;
+                var props = [
+                    'direction',
+                    'boxSizing',
+                    'width',
+                    'height',
+                    'overflowX',
+                    'overflowY',
+                    'borderTopWidth',
+                    'borderRightWidth',
+                    'borderBottomWidth',
+                    'borderLeftWidth',
+                    'paddingTop',
+                    'paddingRight',
+                    'paddingBottom',
+                    'paddingLeft',
+                    'fontStyle',
+                    'fontVariant',
+                    'fontWeight',
+                    'fontStretch',
+                    'fontSize',
+                    'fontSizeAdjust',
+                    'lineHeight',
+                    'fontFamily',
+                    'textAlign',
+                    'textTransform',
+                    'textIndent',
+                    'textDecoration',
+                    'letterSpacing',
+                    'wordSpacing'
+                ];
+                var win = global;
+                var doc = document;
+                var ff = win.mozInnerScreenX !== null && win.mozInnerScreenX !== void 0;
+
+                function tailormade(el, options) {
+                    var textInput = el.tagName === 'INPUT' || el.tagName === 'TEXTAREA';
+                    var throttledRefresh = throttle(refresh, 30);
+                    var o = options || {};
+
+                    bind();
+
+                    return {
+                        read: readPosition,
+                        refresh: throttledRefresh,
+                        destroy: destroy
+                    };
+
+                    function noop() {
+                    }
+
+                    function readPosition() {
+                        return (textInput ? coordsText : coordsHTML)();
+                    }
+
+                    function refresh() {
+                        if (o.sleeping) {
+                            return;
+                        }
+                        return (o.update || noop)(readPosition());
+                    }
+
+                    function coordsText() {
+                        var p = sell(el);
+                        var context = prepare();
+                        var readings = readTextCoords(context, p.start);
+                        doc.body.removeChild(context.mirror);
+                        return readings;
+                    }
+
+                    function coordsHTML() {
+                        var sel = getSelection();
+                        if (sel.rangeCount) {
+                            var range = sel.getRangeAt(0);
+                            var needsToWorkAroundNewlineBug = range.startContainer.nodeName === 'P' && range.startOffset === 0;
+                            if (needsToWorkAroundNewlineBug) {
+                                return {
+                                    x: range.startContainer.offsetLeft,
+                                    y: range.startContainer.offsetTop,
+                                    absolute: true
+                                };
+                            }
+                            if (range.getClientRects) {
+                                var rects = range.getClientRects();
+                                if (rects.length > 0) {
+                                    return {
+                                        x: rects[0].left,
+                                        y: rects[0].top,
+                                        absolute: true
+                                    };
+                                }
+                            }
+                        }
+                        return {x: 0, y: 0};
+                    }
+
+                    function readTextCoords(context, p) {
+                        var rest = doc.createElement('span');
+                        var mirror = context.mirror;
+                        var computed = context.computed;
+
+                        write(mirror, read(el).substring(0, p));
+
+                        if (el.tagName === 'INPUT') {
+                            mirror.textContent = mirror.textContent.replace(/\s/g, '\u00a0');
+                        }
+
+                        write(rest, read(el).substring(p) || '.');
+
+                        mirror.appendChild(rest);
+
+                        return {
+                            x: rest.offsetLeft + parseInt(computed['borderLeftWidth']),
+                            y: rest.offsetTop + parseInt(computed['borderTopWidth'])
+                        };
+                    }
+
+                    function read(el) {
+                        return textInput ? el.value : el.innerHTML;
+                    }
+
+                    function prepare() {
+                        var computed = win.getComputedStyle ? getComputedStyle(el) : el.currentStyle;
+                        var mirror = doc.createElement('div');
+                        var style = mirror.style;
+
+                        doc.body.appendChild(mirror);
+
+                        if (el.tagName !== 'INPUT') {
+                            style.wordWrap = 'break-word';
+                        }
+                        style.whiteSpace = 'pre-wrap';
+                        style.position = 'absolute';
+                        style.visibility = 'hidden';
+                        props.forEach(copy);
+
+                        if (ff) {
+                            style.width = parseInt(computed.width) - 2 + 'px';
+                            if (el.scrollHeight > parseInt(computed.height)) {
+                                style.overflowY = 'scroll';
+                            }
+                        } else {
+                            style.overflow = 'hidden';
+                        }
+                        return {mirror: mirror, computed: computed};
+
+                        function copy(prop) {
+                            style[prop] = computed[prop];
+                        }
+                    }
+
+                    function write(el, value) {
+                        if (textInput) {
+                            el.textContent = value;
+                        } else {
+                            el.innerHTML = value;
+                        }
+                    }
+
+                    function bind(remove) {
+                        var op = remove ? 'remove' : 'add';
+                        crossvent[op](el, 'keydown', throttledRefresh);
+                        crossvent[op](el, 'keyup', throttledRefresh);
+                        crossvent[op](el, 'input', throttledRefresh);
+                        crossvent[op](el, 'paste', throttledRefresh);
+                        crossvent[op](el, 'change', throttledRefresh);
+                    }
+
+                    function destroy() {
+                        bind(true);
+                    }
+                }
+
+                module.exports = tailormade;
+
+            }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+        }, {"./throttle": 5, "crossvent": 8, "seleccion": 27, "sell": 29}],
+        5: [function (require, module, exports) {
+            'use strict';
+
+            function throttle(fn, boundary) {
+                var last = -Infinity;
+                var timer;
+                return function bounced() {
+                    if (timer) {
+                        return;
+                    }
+                    unbound();
+
+                    function unbound() {
+                        clearTimeout(timer);
+                        timer = null;
+                        var next = last + boundary;
+                        var now = Date.now();
+                        if (now > next) {
+                            last = now;
+                            fn();
+                        } else {
+                            timer = setTimeout(unbound, next - now);
+                        }
+                    }
+                };
+            }
+
+            module.exports = throttle;
+
+        }, {}],
+        6: [function (require, module, exports) {
+            'use strict';
+
+            var ticky = require('ticky');
+
+            module.exports = function debounce(fn, args, ctx) {
+                if (!fn) {
+                    return;
+                }
+                ticky(function run() {
+                    fn.apply(ctx || null, args || []);
+                });
+            };
+
+        }, {"ticky": 30}],
+        7: [function (require, module, exports) {
+            'use strict';
+
+            var atoa = require('atoa');
+            var debounce = require('./debounce');
+
+            module.exports = function emitter(thing, options) {
+                var opts = options || {};
+                var evt = {};
+                if (thing === undefined) {
+                    thing = {};
+                }
+                thing.on = function (type, fn) {
+                    if (!evt[type]) {
+                        evt[type] = [fn];
+                    } else {
+                        evt[type].push(fn);
+                    }
+                    return thing;
+                };
+                thing.once = function (type, fn) {
+                    fn._once = true; // thing.off(fn) still works!
+                    thing.on(type, fn);
+                    return thing;
+                };
+                thing.off = function (type, fn) {
+                    var c = arguments.length;
+                    if (c === 1) {
+                        delete evt[type];
+                    } else if (c === 0) {
+                        evt = {};
+                    } else {
+                        var et = evt[type];
+                        if (!et) {
+                            return thing;
+                        }
+                        et.splice(et.indexOf(fn), 1);
+                    }
+                    return thing;
+                };
+                thing.emit = function () {
+                    var args = atoa(arguments);
+                    return thing.emitterSnapshot(args.shift()).apply(this, args);
+                };
+                thing.emitterSnapshot = function (type) {
+                    var et = (evt[type] || []).slice(0);
+                    return function () {
+                        var args = atoa(arguments);
+                        var ctx = this || thing;
+                        if (type === 'error' && opts.throws !== false && !et.length) {
+                            throw args.length === 1 ? args[0] : args;
+                        }
+                        et.forEach(function emitter(listen) {
+                            if (opts.async) {
+                                debounce(listen, args, ctx);
+                            } else {
+                                listen.apply(ctx, args);
+                            }
+                            if (listen._once) {
+                                thing.off(type, listen);
+                            }
+                        });
+                        return thing;
+                    };
+                };
+                return thing;
+            };
+
+        }, {"./debounce": 6, "atoa": 2}],
+        8: [function (require, module, exports) {
+            (function (global) {
+                'use strict';
+
+                var customEvent = require('custom-event');
+                var eventmap = require('./eventmap');
+                var doc = global.document;
+                var addEvent = addEventEasy;
+                var removeEvent = removeEventEasy;
+                var hardCache = [];
+
+                if (!global.addEventListener) {
+                    addEvent = addEventHard;
+                    removeEvent = removeEventHard;
+                }
+
+                module.exports = {
+                    add: addEvent,
+                    remove: removeEvent,
+                    fabricate: fabricateEvent
+                };
+
+                function addEventEasy(el, type, fn, capturing) {
+                    return el.addEventListener(type, fn, capturing);
+                }
+
+                function addEventHard(el, type, fn) {
+                    return el.attachEvent('on' + type, wrap(el, type, fn));
+                }
+
+                function removeEventEasy(el, type, fn, capturing) {
+                    return el.removeEventListener(type, fn, capturing);
+                }
+
+                function removeEventHard(el, type, fn) {
+                    var listener = unwrap(el, type, fn);
+                    if (listener) {
+                        return el.detachEvent('on' + type, listener);
+                    }
+                }
+
+                function fabricateEvent(el, type, model) {
+                    var e = eventmap.indexOf(type) === -1 ? makeCustomEvent() : makeClassicEvent();
+                    if (el.dispatchEvent) {
+                        el.dispatchEvent(e);
+                    } else {
+                        el.fireEvent('on' + type, e);
+                    }
+
+                    function makeClassicEvent() {
+                        var e;
+                        if (doc.createEvent) {
+                            e = doc.createEvent('Event');
+                            e.initEvent(type, true, true);
+                        } else if (doc.createEventObject) {
+                            e = doc.createEventObject();
+                        }
+                        return e;
+                    }
+
+                    function makeCustomEvent() {
+                        return new customEvent(type, {detail: model});
+                    }
+                }
+
+                function wrapperFactory(el, type, fn) {
+                    return function wrapper(originalEvent) {
+                        var e = originalEvent || global.event;
+                        e.target = e.target || e.srcElement;
+                        e.preventDefault = e.preventDefault || function preventDefault() {
+                            e.returnValue = false;
+                        };
+                        e.stopPropagation = e.stopPropagation || function stopPropagation() {
+                            e.cancelBubble = true;
+                        };
+                        e.which = e.which || e.keyCode;
+                        fn.call(el, e);
+                    };
+                }
+
+                function wrap(el, type, fn) {
+                    var wrapper = unwrap(el, type, fn) || wrapperFactory(el, type, fn);
+                    hardCache.push({
+                        wrapper: wrapper,
+                        element: el,
+                        type: type,
+                        fn: fn
+                    });
+                    return wrapper;
+                }
+
+                function unwrap(el, type, fn) {
+                    var i = find(el, type, fn);
+                    if (i) {
+                        var wrapper = hardCache[i].wrapper;
+                        hardCache.splice(i, 1); // free up a tad of memory
+                        return wrapper;
+                    }
+                }
+
+                function find(el, type, fn) {
+                    var i, item;
+                    for (i = 0; i < hardCache.length; i++) {
+                        item = hardCache[i];
+                        if (item.element === el && item.type === type && item.fn === fn) {
+                            return i;
+                        }
+                    }
+                }
+
+            }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+        }, {"./eventmap": 9, "custom-event": 10}],
+        9: [function (require, module, exports) {
+            (function (global) {
+                'use strict';
+
+                var eventmap = [];
+                var eventname = '';
+                var ron = /^on/;
+
+                for (eventname in global) {
+                    if (ron.test(eventname)) {
+                        eventmap.push(eventname.slice(2));
+                    }
+                }
+
+                module.exports = eventmap;
+
+            }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+        }, {}],
+        10: [function (require, module, exports) {
+            (function (global) {
+
+                var NativeCustomEvent = global.CustomEvent;
+
+                function useNative() {
+                    try {
+                        var p = new NativeCustomEvent('cat', {detail: {foo: 'bar'}});
+                        return 'cat' === p.type && 'bar' === p.detail.foo;
+                    } catch (e) {
+                    }
+                    return false;
+                }
+
+                /**
+                 * Cross-browser `CustomEvent` constructor.
+                 *
+                 * https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent.CustomEvent
+                 *
+                 * @public
+                 */
+
+                module.exports = useNative() ? NativeCustomEvent :
+
+                    // IE >= 9
+                    'function' === typeof document.createEvent ? function CustomEvent(type, params) {
+                            var e = document.createEvent('CustomEvent');
+                            if (params) {
+                                e.initCustomEvent(type, params.bubbles, params.cancelable, params.detail);
+                            } else {
+                                e.initCustomEvent(type, false, false, void 0);
+                            }
+                            return e;
+                        } :
+
+                        // IE <= 8
+                        function CustomEvent(type, params) {
+                            var e = document.createEventObject();
+                            e.type = type;
+                            if (params) {
+                                e.bubbles = Boolean(params.bubbles);
+                                e.cancelable = Boolean(params.cancelable);
+                                e.detail = params.detail;
+                            } else {
+                                e.bubbles = false;
+                                e.cancelable = false;
+                                e.detail = void 0;
+                            }
+                            return e;
+                        }
+
+            }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+        }, {}],
+        11: [function (require, module, exports) {
+            'use strict';
+
+            function fuzzysearch(needle, haystack) {
+                var tlen = haystack.length;
+                var qlen = needle.length;
+                if (qlen > tlen) {
+                    return false;
+                }
+                if (qlen === tlen) {
+                    return needle === haystack;
+                }
+                outer: for (var i = 0, j = 0; i < qlen; i++) {
+                    var nch = needle.charCodeAt(i);
+                    while (j < tlen) {
+                        if (haystack.charCodeAt(j++) === nch) {
+                            continue outer;
+                        }
+                    }
+                    return false;
+                }
+                return true;
+            }
+
+            module.exports = fuzzysearch;
+
+        }, {}],
+        12: [function (require, module, exports) {
+            'use strict';
+
+            function pad(hash, len) {
+                while (hash.length < len) {
+                    hash = '0' + hash;
+                }
+                return hash;
+            }
+
+            function fold(hash, text) {
+                var i;
+                var chr;
+                var len;
+                if (text.length === 0) {
+                    return hash;
+                }
+                for (i = 0, len = text.length; i < len; i++) {
+                    chr = text.charCodeAt(i);
+                    hash = ((hash << 5) - hash) + chr;
+                    hash |= 0;
+                }
+                return hash < 0 ? hash * -2 : hash;
+            }
+
+            function foldObject(hash, o, seen) {
+                return Object.keys(o).sort().reduce(foldKey, hash);
+
+                function foldKey(hash, key) {
+                    return foldValue(hash, o[key], key, seen);
+                }
+            }
+
+            function foldValue(input, value, key, seen) {
+                var hash = fold(fold(fold(input, key), toString(value)), typeof value);
+                if (value === null) {
+                    return fold(hash, 'null');
+                }
+                if (value === undefined) {
+                    return fold(hash, 'undefined');
+                }
+                if (typeof value === 'object') {
+                    if (seen.indexOf(value) !== -1) {
+                        return fold(hash, '[Circular]' + key);
+                    }
+                    seen.push(value);
+                    return foldObject(hash, value, seen);
+                }
+                return fold(hash, value.toString());
+            }
+
+            function toString(o) {
+                return Object.prototype.toString.call(o);
+            }
+
+            function sum(o) {
+                return pad(foldValue(0, o, '', []).toString(16), 8);
+            }
+
+            module.exports = sum;
+
+        }, {}],
+        13: [function (require, module, exports) {
+            var isObject = require('./isObject'),
+                now = require('./now'),
+                toNumber = require('./toNumber');
+
+            /** Used as the `TypeError` message for "Functions" methods. */
+            var FUNC_ERROR_TEXT = 'Expected a function';
+
+            /* Built-in method references for those with the same name as other `lodash` methods. */
+            var nativeMax = Math.max,
+                nativeMin = Math.min;
+
+            /**
+             * Creates a debounced function that delays invoking `func` until after `wait`
+             * milliseconds have elapsed since the last time the debounced function was
+             * invoked. The debounced function comes with a `cancel` method to cancel
+             * delayed `func` invocations and a `flush` method to immediately invoke them.
+             * Provide an options object to indicate whether `func` should be invoked on
+             * the leading and/or trailing edge of the `wait` timeout. The `func` is invoked
+             * with the last arguments provided to the debounced function. Subsequent calls
+             * to the debounced function return the result of the last `func` invocation.
+             *
+             * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked
+             * on the trailing edge of the timeout only if the debounced function is
+             * invoked more than once during the `wait` timeout.
+             *
+             * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+             * for details over the differences between `_.debounce` and `_.throttle`.
+             *
+             * @static
+             * @memberOf _
+             * @since 0.1.0
+             * @category Function
+             * @param {Function} func The function to debounce.
+             * @param {number} [wait=0] The number of milliseconds to delay.
+             * @param {Object} [options={}] The options object.
+             * @param {boolean} [options.leading=false]
+             *  Specify invoking on the leading edge of the timeout.
+             * @param {number} [options.maxWait]
+             *  The maximum time `func` is allowed to be delayed before it's invoked.
+             * @param {boolean} [options.trailing=true]
+             *  Specify invoking on the trailing edge of the timeout.
+             * @returns {Function} Returns the new debounced function.
+             * @example
+             *
+             * // Avoid costly calculations while the window size is in flux.
+             * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
+             *
+             * // Invoke `sendMail` when clicked, debouncing subsequent calls.
+             * jQuery(element).on('click', _.debounce(sendMail, 300, {
+             *   'leading': true,
+             *   'trailing': false
+             * }));
+             *
+             * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+             * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
+             * var source = new EventSource('/stream');
+             * jQuery(source).on('message', debounced);
+             *
+             * // Cancel the trailing debounced invocation.
+             * jQuery(window).on('popstate', debounced.cancel);
+             */
+            function debounce(func, wait, options) {
+                var lastArgs,
+                    lastThis,
+                    maxWait,
+                    result,
+                    timerId,
+                    lastCallTime,
+                    lastInvokeTime = 0,
+                    leading = false,
+                    maxing = false,
+                    trailing = true;
+
+                if (typeof func != 'function') {
+                    throw new TypeError(FUNC_ERROR_TEXT);
+                }
+                wait = toNumber(wait) || 0;
+                if (isObject(options)) {
+                    leading = !!options.leading;
+                    maxing = 'maxWait' in options;
+                    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+                    trailing = 'trailing' in options ? !!options.trailing : trailing;
+                }
+
+                function invokeFunc(time) {
+                    var args = lastArgs,
+                        thisArg = lastThis;
+
+                    lastArgs = lastThis = undefined;
+                    lastInvokeTime = time;
+                    result = func.apply(thisArg, args);
+                    return result;
+                }
+
+                function leadingEdge(time) {
+                    // Reset any `maxWait` timer.
+                    lastInvokeTime = time;
+                    // Start the timer for the trailing edge.
+                    timerId = setTimeout(timerExpired, wait);
+                    // Invoke the leading edge.
+                    return leading ? invokeFunc(time) : result;
+                }
+
+                function remainingWait(time) {
+                    var timeSinceLastCall = time - lastCallTime,
+                        timeSinceLastInvoke = time - lastInvokeTime,
+                        result = wait - timeSinceLastCall;
+
+                    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
+                }
+
+                function shouldInvoke(time) {
+                    var timeSinceLastCall = time - lastCallTime,
+                        timeSinceLastInvoke = time - lastInvokeTime;
+
+                    // Either this is the first call, activity has stopped and we're at the
+                    // trailing edge, the system time has gone backwards and we're treating
+                    // it as the trailing edge, or we've hit the `maxWait` limit.
+                    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
+                        (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
+                }
+
+                function timerExpired() {
+                    var time = now();
+                    if (shouldInvoke(time)) {
+                        return trailingEdge(time);
+                    }
+                    // Restart the timer.
+                    timerId = setTimeout(timerExpired, remainingWait(time));
+                }
+
+                function trailingEdge(time) {
+                    timerId = undefined;
+
+                    // Only invoke if we have `lastArgs` which means `func` has been
+                    // debounced at least once.
+                    if (trailing && lastArgs) {
+                        return invokeFunc(time);
+                    }
+                    lastArgs = lastThis = undefined;
+                    return result;
+                }
+
+                function cancel() {
+                    lastInvokeTime = 0;
+                    lastArgs = lastCallTime = lastThis = timerId = undefined;
+                }
+
+                function flush() {
+                    return timerId === undefined ? result : trailingEdge(now());
+                }
+
+                function debounced() {
+                    var time = now(),
+                        isInvoking = shouldInvoke(time);
+
+                    lastArgs = arguments;
+                    lastThis = this;
+                    lastCallTime = time;
+
+                    if (isInvoking) {
+                        if (timerId === undefined) {
+                            return leadingEdge(lastCallTime);
+                        }
+                        if (maxing) {
+                            // Handle invocations in a tight loop.
+                            timerId = setTimeout(timerExpired, wait);
+                            return invokeFunc(lastCallTime);
+                        }
+                    }
+                    if (timerId === undefined) {
+                        timerId = setTimeout(timerExpired, wait);
+                    }
+                    return result;
+                }
+
+                debounced.cancel = cancel;
+                debounced.flush = flush;
+                return debounced;
+            }
+
+            module.exports = debounce;
+
+        }, {"./isObject": 15, "./now": 18, "./toNumber": 19}],
+        14: [function (require, module, exports) {
+            var isObject = require('./isObject');
+
+            /** `Object#toString` result references. */
+            var funcTag = '[object Function]',
+                genTag = '[object GeneratorFunction]';
+
+            /** Used for built-in method references. */
+            var objectProto = Object.prototype;
+
+            /**
+             * Used to resolve the
+             * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
+             * of values.
+             */
+            var objectToString = objectProto.toString;
+
+            /**
+             * Checks if `value` is classified as a `Function` object.
+             *
+             * @static
+             * @memberOf _
+             * @since 0.1.0
+             * @category Lang
+             * @param {*} value The value to check.
+             * @returns {boolean} Returns `true` if `value` is correctly classified,
+             *  else `false`.
+             * @example
+             *
+             * _.isFunction(_);
+             * // => true
+             *
+             * _.isFunction(/abc/);
+             * // => false
+             */
+            function isFunction(value) {
+                // The use of `Object#toString` avoids issues with the `typeof` operator
+                // in Safari 8 which returns 'object' for typed array and weak map constructors,
+                // and PhantomJS 1.9 which returns 'function' for `NodeList` instances.
+                var tag = isObject(value) ? objectToString.call(value) : '';
+                return tag == funcTag || tag == genTag;
+            }
+
+            module.exports = isFunction;
+
+        }, {"./isObject": 15}],
+        15: [function (require, module, exports) {
+            /**
+             * Checks if `value` is the
+             * [language type](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types)
+             * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+             *
+             * @static
+             * @memberOf _
+             * @since 0.1.0
+             * @category Lang
+             * @param {*} value The value to check.
+             * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+             * @example
+             *
+             * _.isObject({});
+             * // => true
+             *
+             * _.isObject([1, 2, 3]);
+             * // => true
+             *
+             * _.isObject(_.noop);
+             * // => true
+             *
+             * _.isObject(null);
+             * // => false
+             */
+            function isObject(value) {
+                var type = typeof value;
+                return !!value && (type == 'object' || type == 'function');
+            }
+
+            module.exports = isObject;
+
+        }, {}],
+        16: [function (require, module, exports) {
+            /**
+             * 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 && typeof value == 'object';
+            }
+
+            module.exports = isObjectLike;
+
+        }, {}],
+        17: [function (require, module, exports) {
+            var isObjectLike = require('./isObjectLike');
+
+            /** `Object#toString` result references. */
+            var symbolTag = '[object Symbol]';
+
+            /** Used for built-in method references. */
+            var objectProto = Object.prototype;
+
+            /**
+             * Used to resolve the
+             * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
+             * of values.
+             */
+            var objectToString = objectProto.toString;
+
+            /**
+             * Checks if `value` is classified as a `Symbol` primitive or object.
+             *
+             * @static
+             * @memberOf _
+             * @since 4.0.0
+             * @category Lang
+             * @param {*} value The value to check.
+             * @returns {boolean} Returns `true` if `value` is correctly classified,
+             *  else `false`.
+             * @example
+             *
+             * _.isSymbol(Symbol.iterator);
+             * // => true
+             *
+             * _.isSymbol('abc');
+             * // => false
+             */
+            function isSymbol(value) {
+                return typeof value == 'symbol' ||
+                    (isObjectLike(value) && objectToString.call(value) == symbolTag);
+            }
+
+            module.exports = isSymbol;
+
+        }, {"./isObjectLike": 16}],
+        18: [function (require, module, exports) {
+            /**
+             * Gets the timestamp of the number of milliseconds that have elapsed since
+             * the Unix epoch (1 January 1970 00:00:00 UTC).
+             *
+             * @static
+             * @memberOf _
+             * @since 2.4.0
+             * @category Date
+             * @returns {number} Returns the timestamp.
+             * @example
+             *
+             * _.defer(function(stamp) {
+             *   console.log(_.now() - stamp);
+             * }, _.now());
+             * // => Logs the number of milliseconds it took for the deferred invocation.
+             */
+            function now() {
+                return Date.now();
+            }
+
+            module.exports = now;
+
+        }, {}],
+        19: [function (require, module, exports) {
+            var isFunction = require('./isFunction'),
+                isObject = require('./isObject'),
+                isSymbol = require('./isSymbol');
+
+            /** Used as references for various `Number` constants. */
+            var NAN = 0 / 0;
+
+            /** Used to match leading and trailing whitespace. */
+            var reTrim = /^\s+|\s+$/g;
+
+            /** Used to detect bad signed hexadecimal string values. */
+            var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+            /** Used to detect binary string values. */
+            var reIsBinary = /^0b[01]+$/i;
+
+            /** Used to detect octal string values. */
+            var reIsOctal = /^0o[0-7]+$/i;
+
+            /** Built-in method references without a dependency on `root`. */
+            var freeParseInt = parseInt;
+
+            /**
+             * Converts `value` to a number.
+             *
+             * @static
+             * @memberOf _
+             * @since 4.0.0
+             * @category Lang
+             * @param {*} value The value to process.
+             * @returns {number} Returns the number.
+             * @example
+             *
+             * _.toNumber(3.2);
+             * // => 3.2
+             *
+             * _.toNumber(Number.MIN_VALUE);
+             * // => 5e-324
+             *
+             * _.toNumber(Infinity);
+             * // => Infinity
+             *
+             * _.toNumber('3.2');
+             * // => 3.2
+             */
+            function toNumber(value) {
+                if (typeof value == 'number') {
+                    return value;
+                }
+                if (isSymbol(value)) {
+                    return NAN;
+                }
+                if (isObject(value)) {
+                    var other = isFunction(value.valueOf) ? value.valueOf() : value;
+                    value = isObject(other) ? (other + '') : other;
+                }
+                if (typeof value != 'string') {
+                    return value === 0 ? value : +value;
+                }
+                value = value.replace(reTrim, '');
+                var isBinary = reIsBinary.test(value);
+                return (isBinary || reIsOctal.test(value))
+                    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+                    : (reIsBadHex.test(value) ? NAN : +value);
+            }
+
+            module.exports = toNumber;
+
+        }, {"./isFunction": 14, "./isObject": 15, "./isSymbol": 17}],
+        20: [function (require, module, exports) {
+            (function (global) {
+                'use strict';
+
+                var expando = 'sektor-' + Date.now();
+                var rsiblings = /[+~]/;
+                var document = global.document;
+                var del = document.documentElement || {};
+                var match = (
+                    del.matches ||
+                    del.webkitMatchesSelector ||
+                    del.mozMatchesSelector ||
+                    del.oMatchesSelector ||
+                    del.msMatchesSelector ||
+                    never
+                );
+
+                module.exports = sektor;
+
+                sektor.matches = matches;
+                sektor.matchesSelector = matchesSelector;
+
+                function qsa(selector, context) {
+                    var existed, id, prefix, prefixed, adapter, hack = context !== document;
+                    if (hack) { // id hack for context-rooted queries
+                        existed = context.getAttribute('id');
+                        id = existed || expando;
+                        prefix = '#' + id + ' ';
+                        prefixed = prefix + selector.replace(/,/g, ',' + prefix);
+                        adapter = rsiblings.test(selector) && context.parentNode;
+                        if (!existed) {
+                            context.setAttribute('id', id);
+                        }
+                    }
+                    try {
+                        return (adapter || context).querySelectorAll(prefixed || selector);
+                    } catch (e) {
+                        return [];
+                    } finally {
+                        if (existed === null) {
+                            context.removeAttribute('id');
+                        }
+                    }
+                }
+
+                function sektor(selector, ctx, collection, seed) {
+                    var element;
+                    var context = ctx || document;
+                    var results = collection || [];
+                    var i = 0;
+                    if (typeof selector !== 'string') {
+                        return results;
+                    }
+                    if (context.nodeType !== 1 && context.nodeType !== 9) {
+                        return []; // bail if context is not an element or document
+                    }
+                    if (seed) {
+                        while ((element = seed[i++])) {
+                            if (matchesSelector(element, selector)) {
+                                results.push(element);
+                            }
+                        }
+                    } else {
+                        results.push.apply(results, qsa(selector, context));
+                    }
+                    return results;
+                }
+
+                function matches(selector, elements) {
+                    return sektor(selector, null, null, elements);
+                }
+
+                function matchesSelector(element, selector) {
+                    return match.call(element, selector);
+                }
+
+                function never() {
+                    return false;
+                }
+
+            }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+        }, {}],
+        21: [function (require, module, exports) {
+            (function (global) {
+                'use strict';
+
+                var getSelection;
+                var doc = global.document;
+                var getSelectionRaw = require('./getSelectionRaw');
+                var getSelectionNullOp = require('./getSelectionNullOp');
+                var getSelectionSynthetic = require('./getSelectionSynthetic');
+                var isHost = require('./isHost');
+                if (isHost.method(global, 'getSelection')) {
+                    getSelection = getSelectionRaw;
+                } else if (typeof doc.selection === 'object' && doc.selection) {
+                    getSelection = getSelectionSynthetic;
+                } else {
+                    getSelection = getSelectionNullOp;
+                }
+
+                module.exports = getSelection;
+
+            }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+        }, {"./getSelectionNullOp": 22, "./getSelectionRaw": 23, "./getSelectionSynthetic": 24, "./isHost": 25}],
+        22: [function (require, module, exports) {
+            'use strict';
+
+            function noop() {
+            }
+
+            function getSelectionNullOp() {
+                return {
+                    removeAllRanges: noop,
+                    addRange: noop
+                };
+            }
+
+            module.exports = getSelectionNullOp;
+
+        }, {}],
+        23: [function (require, module, exports) {
+            (function (global) {
+                'use strict';
+
+                function getSelectionRaw() {
+                    return global.getSelection();
+                }
+
+                module.exports = getSelectionRaw;
+
+            }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+        }, {}],
+        24: [function (require, module, exports) {
+            (function (global) {
+                'use strict';
+
+                var rangeToTextRange = require('./rangeToTextRange');
+                var doc = global.document;
+                var body = doc.body;
+                var GetSelectionProto = GetSelection.prototype;
+
+                function GetSelection(selection) {
+                    var self = this;
+                    var range = selection.createRange();
+
+                    this._selection = selection;
+                    this._ranges = [];
+
+                    if (selection.type === 'Control') {
+                        updateControlSelection(self);
+                    } else if (isTextRange(range)) {
+                        updateFromTextRange(self, range);
+                    } else {
+                        updateEmptySelection(self);
+                    }
+                }
+
+                GetSelectionProto.removeAllRanges = function () {
+                    var textRange;
+                    try {
+                        this._selection.empty();
+                        if (this._selection.type !== 'None') {
+                            textRange = body.createTextRange();
+                            textRange.select();
+                            this._selection.empty();
+                        }
+                    } catch (e) {
+                    }
+                    updateEmptySelection(this);
+                };
+
+                GetSelectionProto.addRange = function (range) {
+                    if (this._selection.type === 'Control') {
+                        addRangeToControlSelection(this, range);
+                    } else {
+                        rangeToTextRange(range).select();
+                        this._ranges[0] = range;
+                        this.rangeCount = 1;
+                        this.isCollapsed = this._ranges[0].collapsed;
+                        updateAnchorAndFocusFromRange(this, range, false);
+                    }
+                };
+
+                GetSelectionProto.setRanges = function (ranges) {
+                    this.removeAllRanges();
+                    var rangeCount = ranges.length;
+                    if (rangeCount > 1) {
+                        createControlSelection(this, ranges);
+                    } else if (rangeCount) {
+                        this.addRange(ranges[0]);
+                    }
+                };
+
+                GetSelectionProto.getRangeAt = function (index) {
+                    if (index < 0 || index >= this.rangeCount) {
+                        throw new Error('getRangeAt(): index out of bounds');
+                    } else {
+                        return this._ranges[index].cloneRange();
+                    }
+                };
+
+                GetSelectionProto.removeRange = function (range) {
+                    if (this._selection.type !== 'Control') {
+                        removeRangeManually(this, range);
+                        return;
+                    }
+                    var controlRange = this._selection.createRange();
+                    var rangeElement = getSingleElementFromRange(range);
+                    var newControlRange = body.createControlRange();
+                    var el;
+                    var removed = false;
+                    for (var i = 0, len = controlRange.length; i < len; ++i) {
+                        el = controlRange.item(i);
+                        if (el !== rangeElement || removed) {
+                            newControlRange.add(controlRange.item(i));
+                        } else {
+                            removed = true;
+                        }
+                    }
+                    newControlRange.select();
+                    updateControlSelection(this);
+                };
+
+                GetSelectionProto.eachRange = function (fn, returnValue) {
+                    var i = 0;
+                    var len = this._ranges.length;
+                    for (i = 0; i < len; ++i) {
+                        if (fn(this.getRangeAt(i))) {
+                            return returnValue;
+                        }
+                    }
+                };
+
+                GetSelectionProto.getAllRanges = function () {
+                    var ranges = [];
+                    this.eachRange(function (range) {
+                        ranges.push(range);
+                    });
+                    return ranges;
+                };
+
+                GetSelectionProto.setSingleRange = function (range) {
+                    this.removeAllRanges();
+                    this.addRange(range);
+                };
+
+                function createControlSelection(sel, ranges) {
+                    var controlRange = body.createControlRange();
+                    for (var i = 0, el, len = ranges.length; i < len; ++i) {
+                        el = getSingleElementFromRange(ranges[i]);
+                        try {
+                            controlRange.add(el);
+                        } catch (e) {
+                            throw new Error('setRanges(): Element could not be added to control selection');
+                        }
+                    }
+                    controlRange.select();
+                    updateControlSelection(sel);
+                }
+
+                function removeRangeManually(sel, range) {
+                    var ranges = sel.getAllRanges();
+                    sel.removeAllRanges();
+                    for (var i = 0, len = ranges.length; i < len; ++i) {
+                        if (!isSameRange(range, ranges[i])) {
+                            sel.addRange(ranges[i]);
+                        }
+                    }
+                    if (!sel.rangeCount) {
+                        updateEmptySelection(sel);
+                    }
+                }
+
+                function updateAnchorAndFocusFromRange(sel, range) {
+                    var anchorPrefix = 'start';
+                    var focusPrefix = 'end';
+                    sel.anchorNode = range[anchorPrefix + 'Container'];
+                    sel.anchorOffset = range[anchorPrefix + 'Offset'];
+                    sel.focusNode = range[focusPrefix + 'Container'];
+                    sel.focusOffset = range[focusPrefix + 'Offset'];
+                }
+
+                function updateEmptySelection(sel) {
+                    sel.anchorNode = sel.focusNode = null;
+                    sel.anchorOffset = sel.focusOffset = 0;
+                    sel.rangeCount = 0;
+                    sel.isCollapsed = true;
+                    sel._ranges.length = 0;
+                }
+
+                function rangeContainsSingleElement(rangeNodes) {
+                    if (!rangeNodes.length || rangeNodes[0].nodeType !== 1) {
+                        return false;
+                    }
+                    for (var i = 1, len = rangeNodes.length; i < len; ++i) {
+                        if (!isAncestorOf(rangeNodes[0], rangeNodes[i])) {
+                            return false;
+                        }
+                    }
+                    return true;
+                }
+
+                function getSingleElementFromRange(range) {
+                    var nodes = range.getNodes();
+                    if (!rangeContainsSingleElement(nodes)) {
+                        throw new Error('getSingleElementFromRange(): range did not consist of a single element');
+                    }
+                    return nodes[0];
+                }
+
+                function isTextRange(range) {
+                    return range && range.text !== void 0;
+                }
+
+                function updateFromTextRange(sel, range) {
+                    sel._ranges = [range];
+                    updateAnchorAndFocusFromRange(sel, range, false);
+                    sel.rangeCount = 1;
+                    sel.isCollapsed = range.collapsed;
+                }
+
+                function updateControlSelection(sel) {
+                    sel._ranges.length = 0;
+                    if (sel._selection.type === 'None') {
+                        updateEmptySelection(sel);
+                    } else {
+                        var controlRange = sel._selection.createRange();
+                        if (isTextRange(controlRange)) {
+                            updateFromTextRange(sel, controlRange);
+                        } else {
+                            sel.rangeCount = controlRange.length;
+                            var range;
+                            for (var i = 0; i < sel.rangeCount; ++i) {
+                                range = doc.createRange();
+                                range.selectNode(controlRange.item(i));
+                                sel._ranges.push(range);
+                            }
+                            sel.isCollapsed = sel.rangeCount === 1 && sel._ranges[0].collapsed;
+                            updateAnchorAndFocusFromRange(sel, sel._ranges[sel.rangeCount - 1], false);
+                        }
+                    }
+                }
+
+                function addRangeToControlSelection(sel, range) {
+                    var controlRange = sel._selection.createRange();
+                    var rangeElement = getSingleElementFromRange(range);
+                    var newControlRange = body.createControlRange();
+                    for (var i = 0, len = controlRange.length; i < len; ++i) {
+                        newControlRange.add(controlRange.item(i));
+                    }
+                    try {
+                        newControlRange.add(rangeElement);
+                    } catch (e) {
+                        throw new Error('addRange(): Element could not be added to control selection');
+                    }
+                    newControlRange.select();
+                    updateControlSelection(sel);
+                }
+
+                function isSameRange(left, right) {
+                    return (
+                        left.startContainer === right.startContainer &&
+                        left.startOffset === right.startOffset &&
+                        left.endContainer === right.endContainer &&
+                        left.endOffset === right.endOffset
+                    );
+                }
+
+                function isAncestorOf(ancestor, descendant) {
+                    var node = descendant;
+                    while (node.parentNode) {
+                        if (node.parentNode === ancestor) {
+                            return true;
+                        }
+                        node = node.parentNode;
+                    }
+                    return false;
+                }
+
+                function getSelection() {
+                    return new GetSelection(global.document.selection);
+                }
+
+                module.exports = getSelection;
+
+            }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+        }, {"./rangeToTextRange": 26}],
+        25: [function (require, module, exports) {
+            'use strict';
+
+            function isHostMethod(host, prop) {
+                var type = typeof host[prop];
+                return type === 'function' || !!(type === 'object' && host[prop]) || type === 'unknown';
+            }
+
+            function isHostProperty(host, prop) {
+                return typeof host[prop] !== 'undefined';
+            }
+
+            function many(fn) {
+                return function areHosted(host, props) {
+                    var i = props.length;
+                    while (i--) {
+                        if (!fn(host, props[i])) {
+                            return false;
+                        }
+                    }
+                    return true;
+                };
+            }
+
+            module.exports = {
+                method: isHostMethod,
+                methods: many(isHostMethod),
+                property: isHostProperty,
+                properties: many(isHostProperty)
+            };
+
+        }, {}],
+        26: [function (require, module, exports) {
+            (function (global) {
+                'use strict';
+
+                var doc = global.document;
+                var body = doc.body;
+
+                function rangeToTextRange(p) {
+                    if (p.collapsed) {
+                        return createBoundaryTextRange({node: p.startContainer, offset: p.startOffset}, true);
+                    }
+                    var startRange = createBoundaryTextRange({node: p.startContainer, offset: p.startOffset}, true);
+                    var endRange = createBoundaryTextRange({node: p.endContainer, offset: p.endOffset}, false);
+                    var textRange = body.createTextRange();
+                    textRange.setEndPoint('StartToStart', startRange);
+                    textRange.setEndPoint('EndToEnd', endRange);
+                    return textRange;
+                }
+
+                function isCharacterDataNode(node) {
+                    var t = node.nodeType;
+                    return t === 3 || t === 4 || t === 8;
+                }
+
+                function createBoundaryTextRange(p, starting) {
+                    var bound;
+                    var parent;
+                    var offset = p.offset;
+                    var workingNode;
+                    var childNodes;
+                    var range = body.createTextRange();
+                    var data = isCharacterDataNode(p.node);
+
+                    if (data) {
+                        bound = p.node;
+                        parent = bound.parentNode;
+                    } else {
+                        childNodes = p.node.childNodes;
+                        bound = offset < childNodes.length ? childNodes[offset] : null;
+                        parent = p.node;
+                    }
+
+                    workingNode = doc.createElement('span');
+                    workingNode.innerHTML = '&#feff;';
+
+                    if (bound) {
+                        parent.insertBefore(workingNode, bound);
+                    } else {
+                        parent.appendChild(workingNode);
+                    }
+
+                    range.moveToElementText(workingNode);
+                    range.collapse(!starting);
+                    parent.removeChild(workingNode);
+
+                    if (data) {
+                        range[starting ? 'moveStart' : 'moveEnd']('character', offset);
+                    }
+                    return range;
+                }
+
+                module.exports = rangeToTextRange;
+
+            }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+        }, {}],
+        27: [function (require, module, exports) {
+            'use strict';
+
+            var getSelection = require('./getSelection');
+            var setSelection = require('./setSelection');
+
+            module.exports = {
+                get: getSelection,
+                set: setSelection
+            };
+
+        }, {"./getSelection": 21, "./setSelection": 28}],
+        28: [function (require, module, exports) {
+            (function (global) {
+                'use strict';
+
+                var getSelection = require('./getSelection');
+                var rangeToTextRange = require('./rangeToTextRange');
+                var doc = global.document;
+
+                function setSelection(p) {
+                    if (doc.createRange) {
+                        modernSelection();
+                    } else {
+                        oldSelection();
+                    }
+
+                    function modernSelection() {
+                        var sel = getSelection();
+                        var range = doc.createRange();
+                        if (!p.startContainer) {
+                            return;
+                        }
+                        if (p.endContainer) {
+                            range.setEnd(p.endContainer, p.endOffset);
+                        } else {
+                            range.setEnd(p.startContainer, p.startOffset);
+                        }
+                        range.setStart(p.startContainer, p.startOffset);
+                        sel.removeAllRanges();
+                        sel.addRange(range);
+                    }
+
+                    function oldSelection() {
+                        rangeToTextRange(p).select();
+                    }
+                }
+
+                module.exports = setSelection;
+
+            }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+        }, {"./getSelection": 21, "./rangeToTextRange": 26}],
+        29: [function (require, module, exports) {
+            'use strict';
+
+            var get = easyGet;
+            var set = easySet;
+
+            if (document.selection && document.selection.createRange) {
+                get = hardGet;
+                set = hardSet;
+            }
+
+            function easyGet(el) {
+                return {
+                    start: el.selectionStart,
+                    end: el.selectionEnd
+                };
+            }
+
+            function hardGet(el) {
+                var active = document.activeElement;
+                if (active !== el) {
+                    el.focus();
+                }
+
+                var range = document.selection.createRange();
+                var bookmark = range.getBookmark();
+                var original = el.value;
+                var marker = getUniqueMarker(original);
+                var parent = range.parentElement();
+                if (parent === null || !inputs(parent)) {
+                    return result(0, 0);
+                }
+                range.text = marker + range.text + marker;
+
+                var contents = el.value;
+
+                el.value = original;
+                range.moveToBookmark(bookmark);
+                range.select();
+
+                return result(contents.indexOf(marker), contents.lastIndexOf(marker) - marker.length);
+
+                function result(start, end) {
+                    if (active !== el) { // don't disrupt pre-existing state
+                        if (active) {
+                            active.focus();
+                        } else {
+                            el.blur();
+                        }
+                    }
+                    return {start: start, end: end};
+                }
+            }
+
+            function getUniqueMarker(contents) {
+                var marker;
+                do {
+                    marker = '@@marker.' + Math.random() * new Date();
+                } while (contents.indexOf(marker) !== -1);
+                return marker;
+            }
+
+            function inputs(el) {
+                return ((el.tagName === 'INPUT' && el.type === 'text') || el.tagName === 'TEXTAREA');
+            }
+
+            function easySet(el, p) {
+                el.selectionStart = parse(el, p.start);
+                el.selectionEnd = parse(el, p.end);
+            }
+
+            function hardSet(el, p) {
+                var range = el.createTextRange();
+
+                if (p.start === 'end' && p.end === 'end') {
+                    range.collapse(false);
+                    range.select();
+                } else {
+                    range.collapse(true);
+                    range.moveEnd('character', parse(el, p.end));
+                    range.moveStart('character', parse(el, p.start));
+                    range.select();
+                }
+            }
+
+            function parse(el, value) {
+                return value === 'end' ? el.value.length : value || 0;
+            }
+
+            function sell(el, p) {
+                if (arguments.length === 2) {
+                    set(el, p);
+                }
+                return get(el);
+            }
+
+            module.exports = sell;
+
+        }, {}],
+        30: [function (require, module, exports) {
+            var si = typeof setImmediate === 'function', tick;
+            if (si) {
+                tick = function (fn) {
+                    setImmediate(fn);
+                };
+            } else {
+                tick = function (fn) {
+                    setTimeout(fn, 0);
+                };
+            }
+
+            module.exports = tick;
+        }, {}]
+    }, {}, [1])(1)
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browserify/node_modules/browser-pack/_prelude.js","horsey.js","node_modules/atoa/atoa.js","node_modules/bullseye/bullseye.js","node_modules/bullseye/tailormade.js","node_modules/bullseye/throttle.js","node_modules/contra/debounce.js","node_modules/contra/emitter.js","node_modules/crossvent/src/crossvent.js","node_modules/crossvent/src/eventmap.js","node_modules/custom-event/index.js","node_modules/fuzzysearch/index.js","node_modules/hash-sum/hash-sum.js","node_modules/lodash/debounce.js","node_modules/lodash/isFunction.js","node_modules/lodash/isObject.js","node_modules/lodash/isObjectLike.js","node_modules/lodash/isSymbol.js","node_modules/lodash/now.js","node_modules/lodash/toNumber.js","node_modules/sektor/src/sektor.js","node_modules/seleccion/src/getSelection.js","node_modules/seleccion/src/getSelectionNullOp.js","node_modules/seleccion/src/getSelectionRaw.js","node_modules/seleccion/src/getSelectionSynthetic.js","node_modules/seleccion/src/isHost.js","node_modules/seleccion/src/rangeToTextRange.js","node_modules/seleccion/src/seleccion.js","node_modules/seleccion/src/setSelection.js","node_modules/sell/sell.js","node_modules/ticky/ticky-browser.js"],"names":[],"mappings":"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AACD,SAAO,KAAP;AACD;;AAED,OAAO,OAAP,GAAiB,MAAjB;;;ACh3BA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACvFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AChLA;AACA;AACA;AACA;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;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACtDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACrGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AChDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;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;;AC7BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvCA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;ACvEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACj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nCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","'use strict';\n\nimport sum from 'hash-sum';\nimport sell from 'sell';\nimport sektor from 'sektor';\nimport emitter from 'contra/emitter';\nimport bullseye from 'bullseye';\nimport crossvent from 'crossvent';\nimport fuzzysearch from 'fuzzysearch';\nimport debounce from 'lodash/debounce';\nconst KEY_BACKSPACE = 8;\nconst KEY_ENTER = 13;\nconst KEY_ESC = 27;\nconst KEY_UP = 38;\nconst KEY_DOWN = 40;\nconst KEY_TAB = 9;\nconst doc = document;\nconst docElement = doc.documentElement;\n\nfunction horsey (el, options = {}) {\n  const {\n    setAppends,\n    set,\n    filter,\n    source,\n    cache = {},\n    predictNextSearch,\n    renderItem,\n    renderCategory,\n    blankSearch,\n    appendTo,\n    anchor,\n    debounce\n  } = options;\n  const caching = options.cache !== false;\n  if (!source) {\n    return;\n  }\n\n  const userGetText = options.getText;\n  const userGetValue = options.getValue;\n  const getText = (\n    typeof userGetText === 'string' ? d => d[userGetText] :\n    typeof userGetText === 'function' ? userGetText :\n    d => d.toString()\n  );\n  const getValue = (\n    typeof userGetValue === 'string' ? d => d[userGetValue] :\n    typeof userGetValue === 'function' ? userGetValue :\n    d => d\n  );\n\n  let previousSuggestions = [];\n  let previousSelection = null;\n  const limit = Number(options.limit) || Infinity;\n  const completer = autocomplete(el, {\n    source: sourceFunction,\n    limit,\n    getText,\n    getValue,\n    setAppends,\n    predictNextSearch,\n    renderItem,\n    renderCategory,\n    appendTo,\n    anchor,\n    noMatches,\n    noMatchesText: options.noMatches,\n    blankSearch,\n    debounce,\n    set (s) {\n      if (setAppends !== true) {\n        el.value = '';\n      }\n      previousSelection = s;\n      (set || completer.defaultSetter)(getText(s), s);\n      completer.emit('afterSet');\n    },\n    filter\n  });\n  return completer;\n  function noMatches (data) {\n    if (!options.noMatches) {\n      return false;\n    }\n    return data.query.length;\n  }\n  function sourceFunction (data, done) {\n    const {query, limit} = data;\n    if (!options.blankSearch && query.length === 0) {\n      done(null, [], true); return;\n    }\n    if (completer) {\n      completer.emit('beforeUpdate');\n    }\n    const hash = sum(query); // fast, case insensitive, prevents collisions\n    if (caching) {\n      const entry = cache[hash];\n      if (entry) {\n        const start = entry.created.getTime();\n        const duration = cache.duration || 60 * 60 * 24;\n        const diff = duration * 1000;\n        const fresh = new Date(start + diff) > new Date();\n        if (fresh) {\n          done(null, entry.items.slice()); return;\n        }\n      }\n    }\n    var sourceData = {\n      previousSuggestions: previousSuggestions.slice(),\n      previousSelection,\n      input: query,\n      renderItem,\n      renderCategory,\n      limit\n    };\n    if (typeof options.source === 'function') {\n      options.source(sourceData, sourced);\n    } else {\n      sourced(null, options.source);\n    }\n    function sourced (err, result) {\n      if (err) {\n        console.log('Autocomplete source error.', err, el);\n        done(err, []);\n      }\n      const items = Array.isArray(result) ? result : [];\n      if (caching) {\n        cache[hash] = { created: new Date(), items };\n      }\n      previousSuggestions = items;\n      done(null, items.slice());\n    }\n  }\n}\n\nfunction autocomplete (el, options = {}) {\n  const o = options;\n  const parent = o.appendTo || doc.body;\n  const {\n    getText,\n    getValue,\n    form,\n    source,\n    noMatches,\n    noMatchesText,\n    highlighter = true,\n    highlightCompleteWords = true,\n    renderItem = defaultItemRenderer,\n    renderCategory = defaultCategoryRenderer,\n    setAppends\n  } = o;\n  const limit = typeof o.limit === 'number' ? o.limit : Infinity;\n  const userFilter = o.filter || defaultFilter;\n  const userSet = o.set || defaultSetter;\n  const categories = tag('div', 'sey-categories');\n  const container = tag('div', 'sey-container');\n  const deferredFiltering = defer(filtering);\n  const state = { counter: 0, query: null };\n  let categoryMap = Object.create(null);\n  let selection = null;\n  let eye;\n  let attachment = el;\n  let noneMatch;\n  let textInput;\n  let anyInput;\n  let ranchorleft;\n  let ranchorright;\n  let lastPrefix = '';\n  const debounceTime = o.debounce || 300;\n  const debouncedLoading = debounce(loading, debounceTime);\n\n  if (o.autoHideOnBlur === void 0) { o.autoHideOnBlur = true; }\n  if (o.autoHideOnClick === void 0) { o.autoHideOnClick = true; }\n  if (o.autoShowOnUpDown === void 0) { o.autoShowOnUpDown = el.tagName === 'INPUT'; }\n  if (o.anchor) {\n    ranchorleft = new RegExp('^' + o.anchor);\n    ranchorright = new RegExp(o.anchor + '$');\n  }\n\n  let hasItems = false;\n  const api = emitter({\n    anchor: o.anchor,\n    clear,\n    show,\n    hide,\n    toggle,\n    destroy,\n    refreshPosition,\n    appendText,\n    appendHTML,\n    filterAnchoredText,\n    filterAnchoredHTML,\n    defaultAppendText: appendText,\n    defaultFilter,\n    defaultItemRenderer,\n    defaultCategoryRenderer,\n    defaultSetter,\n    retarget,\n    attachment,\n    source: []\n  });\n\n  retarget(el);\n  container.appendChild(categories);\n  if (noMatches && noMatchesText) {\n    noneMatch = tag('div', 'sey-empty sey-hide');\n    text(noneMatch, noMatchesText);\n    container.appendChild(noneMatch);\n  }\n  parent.appendChild(container);\n  el.setAttribute('autocomplete', 'off');\n\n  if (Array.isArray(source)) {\n    loaded(source, false);\n  }\n\n  return api;\n\n  function retarget (el) {\n    inputEvents(true);\n    attachment = api.attachment = el;\n    textInput = attachment.tagName === 'INPUT' || attachment.tagName === 'TEXTAREA';\n    anyInput = textInput || isEditable(attachment);\n    inputEvents();\n  }\n\n  function refreshPosition () {\n    if (eye) { eye.refresh(); }\n  }\n\n  function loading (forceShow) {\n    if (typeof source !== 'function') {\n      return;\n    }\n    crossvent.remove(attachment, 'focus', loading);\n    const query = readInput();\n    if (query === state.query) {\n      return;\n    }\n    hasItems = false;\n    state.query = query;\n\n    const counter = ++state.counter;\n\n    source({ query, limit }, sourced);\n\n    function sourced (err, result, blankQuery) {\n      if (state.counter !== counter) {\n        return;\n      }\n      loaded(result, forceShow);\n      if (err || blankQuery) {\n        hasItems = false;\n      }\n    }\n  }\n\n  function loaded (categories, forceShow) {\n    clear();\n    hasItems = true;\n    api.source = [];\n    categories.forEach(cat => cat.list.forEach(suggestion => add(suggestion, cat)));\n    if (forceShow) {\n      show();\n    }\n    filtering();\n  }\n\n  function clear () {\n    unselect();\n    while (categories.lastChild) {\n      categories.removeChild(categories.lastChild);\n    }\n    categoryMap = Object.create(null);\n    hasItems = false;\n  }\n\n  function readInput () {\n    return (textInput ? el.value : el.innerHTML).trim();\n  }\n\n  function getCategory (data) {\n    if (!data.id) {\n      data.id = 'default';\n    }\n    if (!categoryMap[data.id]) {\n      categoryMap[data.id] = createCategory();\n    }\n    return categoryMap[data.id];\n    function createCategory () {\n      const category = tag('div', 'sey-category');\n      const ul = tag('ul', 'sey-list');\n      renderCategory(category, data);\n      category.appendChild(ul);\n      categories.appendChild(category);\n      return { data, ul };\n    }\n  }\n\n  function add (suggestion, categoryData) {\n    const cat = getCategory(categoryData);\n    const li = tag('li', 'sey-item');\n    renderItem(li, suggestion);\n    if (highlighter) {\n      breakupForHighlighter(li);\n    }\n    crossvent.add(li, 'mouseenter', hoverSuggestion);\n    crossvent.add(li, 'click', clickedSuggestion);\n    crossvent.add(li, 'horsey-filter', filterItem);\n    crossvent.add(li, 'horsey-hide', hideItem);\n    cat.ul.appendChild(li);\n    api.source.push(suggestion);\n    return li;\n\n    function hoverSuggestion () {\n      select(li);\n    }\n\n    function clickedSuggestion () {\n      const input = getText(suggestion);\n      set(suggestion);\n      hide();\n      attachment.focus();\n      lastPrefix = o.predictNextSearch && o.predictNextSearch({\n        input: input,\n        source: api.source.slice(),\n        selection: suggestion\n      }) || '';\n      if (lastPrefix) {\n        el.value = lastPrefix;\n        el.select();\n        show();\n        filtering();\n      }\n    }\n\n    function filterItem () {\n      const value = readInput();\n      if (filter(value, suggestion)) {\n        li.className = li.className.replace(/ sey-hide/g, '');\n      } else {\n        crossvent.fabricate(li, 'horsey-hide');\n      }\n    }\n\n    function hideItem () {\n      if (!hidden(li)) {\n        li.className += ' sey-hide';\n        if (selection === li) {\n          unselect();\n        }\n      }\n    }\n  }\n\n  function breakupForHighlighter (el) {\n    getTextChildren(el).forEach(el => {\n      const parent = el.parentElement;\n      const text = el.textContent || el.nodeValue || '';\n      if (text.length === 0) {\n        return;\n      }\n      for (let char of text) {\n        parent.insertBefore(spanFor(char), el);\n      }\n      parent.removeChild(el);\n      function spanFor (char) {\n        const span = doc.createElement('span');\n        span.className = 'sey-char';\n        span.textContent = span.innerText = char;\n        return span;\n      }\n    });\n  }\n\n  function highlight (el, needle) {\n    const rword = /[\\s,._\\[\\]{}()-]/g;\n    const words = needle.split(rword).filter(w => w.length);\n    const elems = [...el.querySelectorAll('.sey-char')];\n    let chars;\n    let startIndex = 0;\n\n    balance();\n    if (highlightCompleteWords) {\n      whole();\n    }\n    fuzzy();\n    clearRemainder();\n\n    function balance () {\n      chars = elems.map(el => el.innerText || el.textContent);\n    }\n\n    function whole () {\n      for (let word of words) {\n        let tempIndex = startIndex;\n        retry: while (tempIndex !== -1) {\n          let init = true;\n          let prevIndex = tempIndex;\n          for (let char of word) {\n            const i = chars.indexOf(char, prevIndex + 1);\n            const fail = i === -1 || (!init && prevIndex + 1 !== i);\n            if (init) {\n              init = false;\n              tempIndex = i;\n            }\n            if (fail) {\n              continue retry;\n            }\n            prevIndex = i;\n          }\n          for (let el of elems.splice(tempIndex, 1 + prevIndex - tempIndex)) {\n            on(el);\n          }\n          balance();\n          needle = needle.replace(word, '');\n          break;\n        }\n      }\n    }\n\n    function fuzzy () {\n      for (let input of needle) {\n        while (elems.length) {\n          let el = elems.shift();\n          if ((el.innerText || el.textContent) === input) {\n            on(el);\n            break;\n          } else {\n            off(el);\n          }\n        }\n      }\n    }\n\n    function clearRemainder () {\n      while (elems.length) {\n        off(elems.shift());\n      }\n    }\n\n    function on (ch) {\n      ch.classList.add('sey-char-highlight');\n    }\n    function off (ch) {\n      ch.classList.remove('sey-char-highlight');\n    }\n  }\n\n  function getTextChildren (el) {\n    const texts = [];\n    const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT, null, false);\n    let node;\n    while (node = walker.nextNode()) {\n      texts.push(node);\n    }\n    return texts;\n  }\n\n  function set (value) {\n    if (o.anchor) {\n      return (isText() ? api.appendText : api.appendHTML)(getValue(value));\n    }\n    userSet(value);\n  }\n\n  function filter (value, suggestion) {\n    if (o.anchor) {\n      const il = (isText() ? api.filterAnchoredText : api.filterAnchoredHTML)(value, suggestion);\n      return il ? userFilter(il.input, il.suggestion) : false;\n    }\n    return userFilter(value, suggestion);\n  }\n\n  function isText () { return isInput(attachment); }\n  function visible () { return container.className.indexOf('sey-show') !== -1; }\n  function hidden (li) { return li.className.indexOf('sey-hide') !== -1; }\n\n  function show () {\n    eye.refresh();\n    if (!visible()) {\n      container.className += ' sey-show';\n      crossvent.fabricate(attachment, 'horsey-show');\n    }\n  }\n\n  function toggler (e) {\n    const left = e.which === 1 && !e.metaKey && !e.ctrlKey;\n    if (left === false) {\n      return; // we only care about honest to god left-clicks\n    }\n    toggle();\n  }\n\n  function toggle () {\n    if (!visible()) {\n      show();\n    } else {\n      hide();\n    }\n  }\n\n  function select (li) {\n    unselect();\n    if (li) {\n      selection = li;\n      selection.className += ' sey-selected';\n    }\n  }\n\n  function unselect () {\n    if (selection) {\n      selection.className = selection.className.replace(/ sey-selected/g, '');\n      selection = null;\n    }\n  }\n\n  function move (up, moves) {\n    const total = api.source.length;\n    if (total === 0) {\n      return;\n    }\n    if (moves > total) {\n      unselect();\n      return;\n    }\n    const cat = findCategory(selection) || categories.firstChild;\n    const first = up ? 'lastChild' : 'firstChild';\n    const last = up ? 'firstChild' : 'lastChild';\n    const next = up ? 'previousSibling' : 'nextSibling';\n    const prev = up ? 'nextSibling' : 'previousSibling';\n    const li = findNext();\n    select(li);\n\n    if (hidden(li)) {\n      move(up, moves ? moves + 1 : 1);\n    }\n\n    function findCategory (el) {\n      while (el) {\n        if (sektor.matchesSelector(el.parentElement, '.sey-category')) {\n          return el.parentElement;\n        }\n        el = el.parentElement;\n      }\n      return null;\n    }\n\n    function findNext () {\n      if (selection) {\n        if (selection[next]) {\n          return selection[next];\n        }\n        if (cat[next] && findList(cat[next])[first]) {\n          return findList(cat[next])[first];\n        }\n      }\n      return findList(categories[first])[first];\n    }\n  }\n\n  function hide () {\n    eye.sleep();\n    container.className = container.className.replace(/ sey-show/g, '');\n    unselect();\n    crossvent.fabricate(attachment, 'horsey-hide');\n    if (el.value === lastPrefix) {\n      el.value = '';\n    }\n  }\n\n  function keydown (e) {\n    const shown = visible();\n    const which = e.which || e.keyCode;\n    if (which === KEY_DOWN) {\n      if (anyInput && o.autoShowOnUpDown) {\n        show();\n      }\n      if (shown) {\n        move();\n        stop(e);\n      }\n    } else if (which === KEY_UP) {\n      if (anyInput && o.autoShowOnUpDown) {\n        show();\n      }\n      if (shown) {\n        move(true);\n        stop(e);\n      }\n    } else if (which === KEY_BACKSPACE) {\n      if (anyInput && o.autoShowOnUpDown) {\n        show();\n      }\n    } else if (shown) {\n      if (which === KEY_ENTER) {\n        if (selection) {\n          crossvent.fabricate(selection, 'click');\n        } else {\n          hide();\n        }\n        stop(e);\n      } else if (which === KEY_ESC) {\n        hide();\n        stop(e);\n      }\n    }\n  }\n\n  function stop (e) {\n    e.stopPropagation();\n    e.preventDefault();\n  }\n\n  function showNoResults () {\n    if (noneMatch) {\n      noneMatch.classList.remove('sey-hide');\n    }\n  }\n\n  function hideNoResults () {\n    if (noneMatch) {\n      noneMatch.classList.add('sey-hide');\n    }\n  }\n\n  function filtering () {\n    if (!visible()) {\n      return;\n    }\n    debouncedLoading(true);\n    crossvent.fabricate(attachment, 'horsey-filter');\n    const value = readInput();\n    if (!o.blankSearch && !value) {\n      hide(); return;\n    }\n    const nomatch = noMatches({ query: value });\n    let count = walkCategories();\n    if (count === 0 && nomatch && hasItems) {\n      showNoResults();\n    } else {\n      hideNoResults();\n    }\n    if (!selection) {\n      move();\n    }\n    if (!selection && !nomatch) {\n      hide();\n    }\n    function walkCategories () {\n      let category = categories.firstChild;\n      let count = 0;\n      while (category) {\n        const list = findList(category);\n        const partial = walkCategory(list);\n        if (partial === 0) {\n          category.classList.add('sey-hide');\n        } else {\n          category.classList.remove('sey-hide');\n        }\n        count += partial;\n        category = category.nextSibling;\n      }\n      return count;\n    }\n    function walkCategory (ul) {\n      let li = ul.firstChild;\n      let count = 0;\n      while (li) {\n        if (count >= limit) {\n          crossvent.fabricate(li, 'horsey-hide');\n        } else {\n          crossvent.fabricate(li, 'horsey-filter');\n          if (li.className.indexOf('sey-hide') === -1) {\n            count++;\n            if (highlighter) {\n              highlight(li, value);\n            }\n          }\n        }\n        li = li.nextSibling;\n      }\n      return count;\n    }\n  }\n\n  function deferredFilteringNoEnter (e) {\n    const which = e.which || e.keyCode;\n    if (which === KEY_ENTER) {\n      return;\n    }\n    deferredFiltering();\n  }\n\n  function deferredShow (e) {\n    const which = e.which || e.keyCode;\n    if (which === KEY_ENTER || which === KEY_TAB) {\n      return;\n    }\n    setTimeout(show, 0);\n  }\n\n  function autocompleteEventTarget (e) {\n    let target = e.target;\n    if (target === attachment) {\n      return true;\n    }\n    while (target) {\n      if (target === container || target === attachment) {\n        return true;\n      }\n      target = target.parentNode;\n    }\n  }\n\n  function hideOnBlur (e) {\n    const which = e.which || e.keyCode;\n    if (which === KEY_TAB) {\n      hide();\n    }\n  }\n\n  function hideOnClick (e) {\n    if (autocompleteEventTarget(e)) {\n      return;\n    }\n    hide();\n  }\n\n  function inputEvents (remove) {\n    const op = remove ? 'remove' : 'add';\n    if (eye) {\n      eye.destroy();\n      eye = null;\n    }\n    if (!remove) {\n      eye = bullseye(container, attachment, {\n        caret: anyInput && attachment.tagName !== 'INPUT',\n        context: o.appendTo\n      });\n      if (!visible()) { eye.sleep(); }\n    }\n    if (remove || (anyInput && doc.activeElement !== attachment)) {\n      crossvent[op](attachment, 'focus', loading);\n    } else {\n      loading();\n    }\n    if (anyInput) {\n      crossvent[op](attachment, 'keypress', deferredShow);\n      crossvent[op](attachment, 'keypress', deferredFiltering);\n      crossvent[op](attachment, 'keydown', deferredFilteringNoEnter);\n      crossvent[op](attachment, 'paste', deferredFiltering);\n      crossvent[op](attachment, 'keydown', keydown);\n      if (o.autoHideOnBlur) { crossvent[op](attachment, 'keydown', hideOnBlur); }\n    } else {\n      crossvent[op](attachment, 'click', toggler);\n      crossvent[op](docElement, 'keydown', keydown);\n    }\n    if (o.autoHideOnClick) { crossvent[op](doc, 'click', hideOnClick); }\n    if (form) { crossvent[op](form, 'submit', hide); }\n  }\n\n  function destroy () {\n    inputEvents(true);\n    if (parent.contains(container)) { parent.removeChild(container); }\n  }\n\n  function defaultSetter (value) {\n    if (textInput) {\n      if (setAppends === true) {\n        el.value += ' ' + value;\n      } else {\n        el.value = value;\n      }\n    } else {\n      if (setAppends === true) {\n        el.innerHTML += ' ' + value;\n      } else {\n        el.innerHTML = value;\n      }\n    }\n  }\n\n  function defaultItemRenderer (li, suggestion) {\n    text(li, getText(suggestion));\n  }\n\n  function defaultCategoryRenderer (div, data) {\n    if (data.id !== 'default') {\n      const id = tag('div', 'sey-category-id');\n      div.appendChild(id);\n      text(id, data.id);\n    }\n  }\n\n  function defaultFilter (q, suggestion) {\n    const needle = q.toLowerCase();\n    const text = getText(suggestion) || '';\n    if (fuzzysearch(needle, text.toLowerCase())) {\n      return true;\n    }\n    const value = getValue(suggestion) || '';\n    if (typeof value !== 'string') {\n      return false;\n    }\n    return fuzzysearch(needle, value.toLowerCase());\n  }\n\n  function loopbackToAnchor (text, p) {\n    let result = '';\n    let anchored = false;\n    let start = p.start;\n    while (anchored === false && start >= 0) {\n      result = text.substr(start - 1, p.start - start + 1);\n      anchored = ranchorleft.test(result);\n      start--;\n    }\n    return {\n      text: anchored ? result : null,\n      start\n    };\n  }\n\n  function filterAnchoredText (q, suggestion) {\n    const position = sell(el);\n    const input = loopbackToAnchor(q, position).text;\n    if (input) {\n      return { input, suggestion };\n    }\n  }\n\n  function appendText (value) {\n    const current = el.value;\n    const position = sell(el);\n    const input = loopbackToAnchor(current, position);\n    const left = current.substr(0, input.start);\n    const right = current.substr(input.start + input.text.length + (position.end - position.start));\n    const before = left + value + ' ';\n\n    el.value = before + right;\n    sell(el, { start: before.length, end: before.length });\n  }\n\n  function filterAnchoredHTML () {\n    throw new Error('Anchoring in editable elements is disabled by default.');\n  }\n\n  function appendHTML () {\n    throw new Error('Anchoring in editable elements is disabled by default.');\n  }\n\n  function findList (category) { return sektor('.sey-list', category)[0]; }\n}\n\nfunction isInput (el) { return el.tagName === 'INPUT' || el.tagName === 'TEXTAREA'; }\n\nfunction tag (type, className) {\n  const el = doc.createElement(type);\n  el.className = className;\n  return el;\n}\n\nfunction defer (fn) { return function () { setTimeout(fn, 0); }; }\nfunction text (el, value) { el.innerText = el.textContent = value; }\n\nfunction isEditable (el) {\n  const value = el.getAttribute('contentEditable');\n  if (value === 'false') {\n    return false;\n  }\n  if (value === 'true') {\n    return true;\n  }\n  if (el.parentElement) {\n    return isEditable(el.parentElement);\n  }\n  return false;\n}\n\nmodule.exports = horsey;\n","module.exports = function atoa (a, n) { return Array.prototype.slice.call(a, n); }\n","'use strict';\n\nvar crossvent = require('crossvent');\nvar throttle = require('./throttle');\nvar tailormade = require('./tailormade');\n\nfunction bullseye (el, target, options) {\n  var o = options;\n  var domTarget = target && target.tagName;\n\n  if (!domTarget && arguments.length === 2) {\n    o = target;\n  }\n  if (!domTarget) {\n    target = el;\n  }\n  if (!o) { o = {}; }\n\n  var destroyed = false;\n  var throttledWrite = throttle(write, 30);\n  var tailorOptions = { update: o.autoupdateToCaret !== false && update };\n  var tailor = o.caret && tailormade(target, tailorOptions);\n\n  write();\n\n  if (o.tracking !== false) {\n    crossvent.add(window, 'resize', throttledWrite);\n  }\n\n  return {\n    read: readNull,\n    refresh: write,\n    destroy: destroy,\n    sleep: sleep\n  };\n\n  function sleep () {\n    tailorOptions.sleeping = true;\n  }\n\n  function readNull () { return read(); }\n\n  function read (readings) {\n    var bounds = target.getBoundingClientRect();\n    var scrollTop = document.body.scrollTop || document.documentElement.scrollTop;\n    if (tailor) {\n      readings = tailor.read();\n      return {\n        x: (readings.absolute ? 0 : bounds.left) + readings.x,\n        y: (readings.absolute ? 0 : bounds.top) + scrollTop + readings.y + 20\n      };\n    }\n    return {\n      x: bounds.left,\n      y: bounds.top + scrollTop\n    };\n  }\n\n  function update (readings) {\n    write(readings);\n  }\n\n  function write (readings) {\n    if (destroyed) {\n      throw new Error('Bullseye can\\'t refresh after being destroyed. Create another instance instead.');\n    }\n    if (tailor && !readings) {\n      tailorOptions.sleeping = false;\n      tailor.refresh(); return;\n    }\n    var p = read(readings);\n    if (!tailor && target !== el) {\n      p.y += target.offsetHeight;\n    }\n    var context = o.context;\n    el.style.left = p.x + 'px';\n    el.style.top = (context ? context.offsetHeight : p.y) + 'px';\n  }\n\n  function destroy () {\n    if (tailor) { tailor.destroy(); }\n    crossvent.remove(window, 'resize', throttledWrite);\n    destroyed = true;\n  }\n}\n\nmodule.exports = bullseye;\n","'use strict';\n\nvar sell = require('sell');\nvar crossvent = require('crossvent');\nvar seleccion = require('seleccion');\nvar throttle = require('./throttle');\nvar getSelection = seleccion.get;\nvar props = [\n  'direction',\n  'boxSizing',\n  'width',\n  'height',\n  'overflowX',\n  'overflowY',\n  'borderTopWidth',\n  'borderRightWidth',\n  'borderBottomWidth',\n  'borderLeftWidth',\n  'paddingTop',\n  'paddingRight',\n  'paddingBottom',\n  'paddingLeft',\n  'fontStyle',\n  'fontVariant',\n  'fontWeight',\n  'fontStretch',\n  'fontSize',\n  'fontSizeAdjust',\n  'lineHeight',\n  'fontFamily',\n  'textAlign',\n  'textTransform',\n  'textIndent',\n  'textDecoration',\n  'letterSpacing',\n  'wordSpacing'\n];\nvar win = global;\nvar doc = document;\nvar ff = win.mozInnerScreenX !== null && win.mozInnerScreenX !== void 0;\n\nfunction tailormade (el, options) {\n  var textInput = el.tagName === 'INPUT' || el.tagName === 'TEXTAREA';\n  var throttledRefresh = throttle(refresh, 30);\n  var o = options || {};\n\n  bind();\n\n  return {\n    read: readPosition,\n    refresh: throttledRefresh,\n    destroy: destroy\n  };\n\n  function noop () {}\n  function readPosition () { return (textInput ? coordsText : coordsHTML)(); }\n\n  function refresh () {\n    if (o.sleeping) {\n      return;\n    }\n    return (o.update || noop)(readPosition());\n  }\n\n  function coordsText () {\n    var p = sell(el);\n    var context = prepare();\n    var readings = readTextCoords(context, p.start);\n    doc.body.removeChild(context.mirror);\n    return readings;\n  }\n\n  function coordsHTML () {\n    var sel = getSelection();\n    if (sel.rangeCount) {\n      var range = sel.getRangeAt(0);\n      var needsToWorkAroundNewlineBug = range.startContainer.nodeName === 'P' && range.startOffset === 0;\n      if (needsToWorkAroundNewlineBug) {\n        return {\n          x: range.startContainer.offsetLeft,\n          y: range.startContainer.offsetTop,\n          absolute: true\n        };\n      }\n      if (range.getClientRects) {\n        var rects = range.getClientRects();\n        if (rects.length > 0) {\n          return {\n            x: rects[0].left,\n            y: rects[0].top,\n            absolute: true\n          };\n        }\n      }\n    }\n    return { x: 0, y: 0 };\n  }\n\n  function readTextCoords (context, p) {\n    var rest = doc.createElement('span');\n    var mirror = context.mirror;\n    var computed = context.computed;\n\n    write(mirror, read(el).substring(0, p));\n\n    if (el.tagName === 'INPUT') {\n      mirror.textContent = mirror.textContent.replace(/\\s/g, '\\u00a0');\n    }\n\n    write(rest, read(el).substring(p) || '.');\n\n    mirror.appendChild(rest);\n\n    return {\n      x: rest.offsetLeft + parseInt(computed['borderLeftWidth']),\n      y: rest.offsetTop + parseInt(computed['borderTopWidth'])\n    };\n  }\n\n  function read (el) {\n    return textInput ? el.value : el.innerHTML;\n  }\n\n  function prepare () {\n    var computed = win.getComputedStyle ? getComputedStyle(el) : el.currentStyle;\n    var mirror = doc.createElement('div');\n    var style = mirror.style;\n\n    doc.body.appendChild(mirror);\n\n    if (el.tagName !== 'INPUT') {\n      style.wordWrap = 'break-word';\n    }\n    style.whiteSpace = 'pre-wrap';\n    style.position = 'absolute';\n    style.visibility = 'hidden';\n    props.forEach(copy);\n\n    if (ff) {\n      style.width = parseInt(computed.width) - 2 + 'px';\n      if (el.scrollHeight > parseInt(computed.height)) {\n        style.overflowY = 'scroll';\n      }\n    } else {\n      style.overflow = 'hidden';\n    }\n    return { mirror: mirror, computed: computed };\n\n    function copy (prop) {\n      style[prop] = computed[prop];\n    }\n  }\n\n  function write (el, value) {\n    if (textInput) {\n      el.textContent = value;\n    } else {\n      el.innerHTML = value;\n    }\n  }\n\n  function bind (remove) {\n    var op = remove ? 'remove' : 'add';\n    crossvent[op](el, 'keydown', throttledRefresh);\n    crossvent[op](el, 'keyup', throttledRefresh);\n    crossvent[op](el, 'input', throttledRefresh);\n    crossvent[op](el, 'paste', throttledRefresh);\n    crossvent[op](el, 'change', throttledRefresh);\n  }\n\n  function destroy () {\n    bind(true);\n  }\n}\n\nmodule.exports = tailormade;\n","'use strict';\n\nfunction throttle (fn, boundary) {\n  var last = -Infinity;\n  var timer;\n  return function bounced () {\n    if (timer) {\n      return;\n    }\n    unbound();\n\n    function unbound () {\n      clearTimeout(timer);\n      timer = null;\n      var next = last + boundary;\n      var now = Date.now();\n      if (now > next) {\n        last = now;\n        fn();\n      } else {\n        timer = setTimeout(unbound, next - now);\n      }\n    }\n  };\n}\n\nmodule.exports = throttle;\n","'use strict';\n\nvar ticky = require('ticky');\n\nmodule.exports = function debounce (fn, args, ctx) {\n  if (!fn) { return; }\n  ticky(function run () {\n    fn.apply(ctx || null, args || []);\n  });\n};\n","'use strict';\n\nvar atoa = require('atoa');\nvar debounce = require('./debounce');\n\nmodule.exports = function emitter (thing, options) {\n  var opts = options || {};\n  var evt = {};\n  if (thing === undefined) { thing = {}; }\n  thing.on = function (type, fn) {\n    if (!evt[type]) {\n      evt[type] = [fn];\n    } else {\n      evt[type].push(fn);\n    }\n    return thing;\n  };\n  thing.once = function (type, fn) {\n    fn._once = true; // thing.off(fn) still works!\n    thing.on(type, fn);\n    return thing;\n  };\n  thing.off = function (type, fn) {\n    var c = arguments.length;\n    if (c === 1) {\n      delete evt[type];\n    } else if (c === 0) {\n      evt = {};\n    } else {\n      var et = evt[type];\n      if (!et) { return thing; }\n      et.splice(et.indexOf(fn), 1);\n    }\n    return thing;\n  };\n  thing.emit = function () {\n    var args = atoa(arguments);\n    return thing.emitterSnapshot(args.shift()).apply(this, args);\n  };\n  thing.emitterSnapshot = function (type) {\n    var et = (evt[type] || []).slice(0);\n    return function () {\n      var args = atoa(arguments);\n      var ctx = this || thing;\n      if (type === 'error' && opts.throws !== false && !et.length) { throw args.length === 1 ? args[0] : args; }\n      et.forEach(function emitter (listen) {\n        if (opts.async) { debounce(listen, args, ctx); } else { listen.apply(ctx, args); }\n        if (listen._once) { thing.off(type, listen); }\n      });\n      return thing;\n    };\n  };\n  return thing;\n};\n","'use strict';\n\nvar customEvent = require('custom-event');\nvar eventmap = require('./eventmap');\nvar doc = global.document;\nvar addEvent = addEventEasy;\nvar removeEvent = removeEventEasy;\nvar hardCache = [];\n\nif (!global.addEventListener) {\n  addEvent = addEventHard;\n  removeEvent = removeEventHard;\n}\n\nmodule.exports = {\n  add: addEvent,\n  remove: removeEvent,\n  fabricate: fabricateEvent\n};\n\nfunction addEventEasy (el, type, fn, capturing) {\n  return el.addEventListener(type, fn, capturing);\n}\n\nfunction addEventHard (el, type, fn) {\n  return el.attachEvent('on' + type, wrap(el, type, fn));\n}\n\nfunction removeEventEasy (el, type, fn, capturing) {\n  return el.removeEventListener(type, fn, capturing);\n}\n\nfunction removeEventHard (el, type, fn) {\n  var listener = unwrap(el, type, fn);\n  if (listener) {\n    return el.detachEvent('on' + type, listener);\n  }\n}\n\nfunction fabricateEvent (el, type, model) {\n  var e = eventmap.indexOf(type) === -1 ? makeCustomEvent() : makeClassicEvent();\n  if (el.dispatchEvent) {\n    el.dispatchEvent(e);\n  } else {\n    el.fireEvent('on' + type, e);\n  }\n  function makeClassicEvent () {\n    var e;\n    if (doc.createEvent) {\n      e = doc.createEvent('Event');\n      e.initEvent(type, true, true);\n    } else if (doc.createEventObject) {\n      e = doc.createEventObject();\n    }\n    return e;\n  }\n  function makeCustomEvent () {\n    return new customEvent(type, { detail: model });\n  }\n}\n\nfunction wrapperFactory (el, type, fn) {\n  return function wrapper (originalEvent) {\n    var e = originalEvent || global.event;\n    e.target = e.target || e.srcElement;\n    e.preventDefault = e.preventDefault || function preventDefault () { e.returnValue = false; };\n    e.stopPropagation = e.stopPropagation || function stopPropagation () { e.cancelBubble = true; };\n    e.which = e.which || e.keyCode;\n    fn.call(el, e);\n  };\n}\n\nfunction wrap (el, type, fn) {\n  var wrapper = unwrap(el, type, fn) || wrapperFactory(el, type, fn);\n  hardCache.push({\n    wrapper: wrapper,\n    element: el,\n    type: type,\n    fn: fn\n  });\n  return wrapper;\n}\n\nfunction unwrap (el, type, fn) {\n  var i = find(el, type, fn);\n  if (i) {\n    var wrapper = hardCache[i].wrapper;\n    hardCache.splice(i, 1); // free up a tad of memory\n    return wrapper;\n  }\n}\n\nfunction find (el, type, fn) {\n  var i, item;\n  for (i = 0; i < hardCache.length; i++) {\n    item = hardCache[i];\n    if (item.element === el && item.type === type && item.fn === fn) {\n      return i;\n    }\n  }\n}\n","'use strict';\n\nvar eventmap = [];\nvar eventname = '';\nvar ron = /^on/;\n\nfor (eventname in global) {\n  if (ron.test(eventname)) {\n    eventmap.push(eventname.slice(2));\n  }\n}\n\nmodule.exports = eventmap;\n","\nvar NativeCustomEvent = global.CustomEvent;\n\nfunction useNative () {\n  try {\n    var p = new NativeCustomEvent('cat', { detail: { foo: 'bar' } });\n    return  'cat' === p.type && 'bar' === p.detail.foo;\n  } catch (e) {\n  }\n  return false;\n}\n\n/**\n * Cross-browser `CustomEvent` constructor.\n *\n * https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent.CustomEvent\n *\n * @public\n */\n\nmodule.exports = useNative() ? NativeCustomEvent :\n\n// IE >= 9\n'function' === typeof document.createEvent ? function CustomEvent (type, params) {\n  var e = document.createEvent('CustomEvent');\n  if (params) {\n    e.initCustomEvent(type, params.bubbles, params.cancelable, params.detail);\n  } else {\n    e.initCustomEvent(type, false, false, void 0);\n  }\n  return e;\n} :\n\n// IE <= 8\nfunction CustomEvent (type, params) {\n  var e = document.createEventObject();\n  e.type = type;\n  if (params) {\n    e.bubbles = Boolean(params.bubbles);\n    e.cancelable = Boolean(params.cancelable);\n    e.detail = params.detail;\n  } else {\n    e.bubbles = false;\n    e.cancelable = false;\n    e.detail = void 0;\n  }\n  return e;\n}\n","'use strict';\n\nfunction fuzzysearch (needle, haystack) {\n  var tlen = haystack.length;\n  var qlen = needle.length;\n  if (qlen > tlen) {\n    return false;\n  }\n  if (qlen === tlen) {\n    return needle === haystack;\n  }\n  outer: for (var i = 0, j = 0; i < qlen; i++) {\n    var nch = needle.charCodeAt(i);\n    while (j < tlen) {\n      if (haystack.charCodeAt(j++) === nch) {\n        continue outer;\n      }\n    }\n    return false;\n  }\n  return true;\n}\n\nmodule.exports = fuzzysearch;\n","'use strict';\n\nfunction pad (hash, len) {\n  while (hash.length < len) {\n    hash = '0' + hash;\n  }\n  return hash;\n}\n\nfunction fold (hash, text) {\n  var i;\n  var chr;\n  var len;\n  if (text.length === 0) {\n    return hash;\n  }\n  for (i = 0, len = text.length; i < len; i++) {\n    chr = text.charCodeAt(i);\n    hash = ((hash << 5) - hash) + chr;\n    hash |= 0;\n  }\n  return hash < 0 ? hash * -2 : hash;\n}\n\nfunction foldObject (hash, o, seen) {\n  return Object.keys(o).sort().reduce(foldKey, hash);\n  function foldKey (hash, key) {\n    return foldValue(hash, o[key], key, seen);\n  }\n}\n\nfunction foldValue (input, value, key, seen) {\n  var hash = fold(fold(fold(input, key), toString(value)), typeof value);\n  if (value === null) {\n    return fold(hash, 'null');\n  }\n  if (value === undefined) {\n    return fold(hash, 'undefined');\n  }\n  if (typeof value === 'object') {\n    if (seen.indexOf(value) !== -1) {\n      return fold(hash, '[Circular]' + key);\n    }\n    seen.push(value);\n    return foldObject(hash, value, seen);\n  }\n  return fold(hash, value.toString());\n}\n\nfunction toString (o) {\n  return Object.prototype.toString.call(o);\n}\n\nfunction sum (o) {\n  return pad(foldValue(0, o, '', []).toString(16), 8);\n}\n\nmodule.exports = sum;\n","var isObject = require('./isObject'),\n    now = require('./now'),\n    toNumber = require('./toNumber');\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide an options object to indicate whether `func` should be invoked on\n * the leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent calls\n * to the debounced function return the result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked\n * on the trailing edge of the timeout only if the debounced function is\n * invoked more than once during the `wait` timeout.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nmodule.exports = debounce;\n","var isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar funcTag = '[object Function]',\n    genTag = '[object GeneratorFunction]';\n\n/** 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/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n *  else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 8 which returns 'object' for typed array and weak map constructors,\n  // and PhantomJS 1.9 which returns 'function' for `NodeList` instances.\n  var tag = isObject(value) ? objectToString.call(value) : '';\n  return tag == funcTag || tag == genTag;\n}\n\nmodule.exports = isFunction;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","/**\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 && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** 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/6.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or 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 correctly classified,\n *  else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nfunction now() {\n  return Date.now();\n}\n\nmodule.exports = now;\n","var isFunction = require('./isFunction'),\n    isObject = require('./isObject'),\n    isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = isFunction(value.valueOf) ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n","'use strict';\n\nvar expando = 'sektor-' + Date.now();\nvar rsiblings = /[+~]/;\nvar document = global.document;\nvar del = document.documentElement || {};\nvar match = (\n  del.matches ||\n  del.webkitMatchesSelector ||\n  del.mozMatchesSelector ||\n  del.oMatchesSelector ||\n  del.msMatchesSelector ||\n  never\n);\n\nmodule.exports = sektor;\n\nsektor.matches = matches;\nsektor.matchesSelector = matchesSelector;\n\nfunction qsa (selector, context) {\n  var existed, id, prefix, prefixed, adapter, hack = context !== document;\n  if (hack) { // id hack for context-rooted queries\n    existed = context.getAttribute('id');\n    id = existed || expando;\n    prefix = '#' + id + ' ';\n    prefixed = prefix + selector.replace(/,/g, ',' + prefix);\n    adapter = rsiblings.test(selector) && context.parentNode;\n    if (!existed) { context.setAttribute('id', id); }\n  }\n  try {\n    return (adapter || context).querySelectorAll(prefixed || selector);\n  } catch (e) {\n    return [];\n  } finally {\n    if (existed === null) { context.removeAttribute('id'); }\n  }\n}\n\nfunction sektor (selector, ctx, collection, seed) {\n  var element;\n  var context = ctx || document;\n  var results = collection || [];\n  var i = 0;\n  if (typeof selector !== 'string') {\n    return results;\n  }\n  if (context.nodeType !== 1 && context.nodeType !== 9) {\n    return []; // bail if context is not an element or document\n  }\n  if (seed) {\n    while ((element = seed[i++])) {\n      if (matchesSelector(element, selector)) {\n        results.push(element);\n      }\n    }\n  } else {\n    results.push.apply(results, qsa(selector, context));\n  }\n  return results;\n}\n\nfunction matches (selector, elements) {\n  return sektor(selector, null, null, elements);\n}\n\nfunction matchesSelector (element, selector) {\n  return match.call(element, selector);\n}\n\nfunction never () { return false; }\n","'use strict';\n\nvar getSelection;\nvar doc = global.document;\nvar getSelectionRaw = require('./getSelectionRaw');\nvar getSelectionNullOp = require('./getSelectionNullOp');\nvar getSelectionSynthetic = require('./getSelectionSynthetic');\nvar isHost = require('./isHost');\nif (isHost.method(global, 'getSelection')) {\n  getSelection = getSelectionRaw;\n} else if (typeof doc.selection === 'object' && doc.selection) {\n  getSelection = getSelectionSynthetic;\n} else {\n  getSelection = getSelectionNullOp;\n}\n\nmodule.exports = getSelection;\n","'use strict';\n\nfunction noop () {}\n\nfunction getSelectionNullOp () {\n  return {\n    removeAllRanges: noop,\n    addRange: noop\n  };\n}\n\nmodule.exports = getSelectionNullOp;\n","'use strict';\n\nfunction getSelectionRaw () {\n  return global.getSelection();\n}\n\nmodule.exports = getSelectionRaw;\n","'use strict';\n\nvar rangeToTextRange = require('./rangeToTextRange');\nvar doc = global.document;\nvar body = doc.body;\nvar GetSelectionProto = GetSelection.prototype;\n\nfunction GetSelection (selection) {\n  var self = this;\n  var range = selection.createRange();\n\n  this._selection = selection;\n  this._ranges = [];\n\n  if (selection.type === 'Control') {\n    updateControlSelection(self);\n  } else if (isTextRange(range)) {\n    updateFromTextRange(self, range);\n  } else {\n    updateEmptySelection(self);\n  }\n}\n\nGetSelectionProto.removeAllRanges = function () {\n  var textRange;\n  try {\n    this._selection.empty();\n    if (this._selection.type !== 'None') {\n      textRange = body.createTextRange();\n      textRange.select();\n      this._selection.empty();\n    }\n  } catch (e) {\n  }\n  updateEmptySelection(this);\n};\n\nGetSelectionProto.addRange = function (range) {\n  if (this._selection.type === 'Control') {\n    addRangeToControlSelection(this, range);\n  } else {\n    rangeToTextRange(range).select();\n    this._ranges[0] = range;\n    this.rangeCount = 1;\n    this.isCollapsed = this._ranges[0].collapsed;\n    updateAnchorAndFocusFromRange(this, range, false);\n  }\n};\n\nGetSelectionProto.setRanges = function (ranges) {\n  this.removeAllRanges();\n  var rangeCount = ranges.length;\n  if (rangeCount > 1) {\n    createControlSelection(this, ranges);\n  } else if (rangeCount) {\n    this.addRange(ranges[0]);\n  }\n};\n\nGetSelectionProto.getRangeAt = function (index) {\n  if (index < 0 || index >= this.rangeCount) {\n    throw new Error('getRangeAt(): index out of bounds');\n  } else {\n    return this._ranges[index].cloneRange();\n  }\n};\n\nGetSelectionProto.removeRange = function (range) {\n  if (this._selection.type !== 'Control') {\n    removeRangeManually(this, range);\n    return;\n  }\n  var controlRange = this._selection.createRange();\n  var rangeElement = getSingleElementFromRange(range);\n  var newControlRange = body.createControlRange();\n  var el;\n  var removed = false;\n  for (var i = 0, len = controlRange.length; i < len; ++i) {\n    el = controlRange.item(i);\n    if (el !== rangeElement || removed) {\n      newControlRange.add(controlRange.item(i));\n    } else {\n      removed = true;\n    }\n  }\n  newControlRange.select();\n  updateControlSelection(this);\n};\n\nGetSelectionProto.eachRange = function (fn, returnValue) {\n  var i = 0;\n  var len = this._ranges.length;\n  for (i = 0; i < len; ++i) {\n    if (fn(this.getRangeAt(i))) {\n      return returnValue;\n    }\n  }\n};\n\nGetSelectionProto.getAllRanges = function () {\n  var ranges = [];\n  this.eachRange(function (range) {\n    ranges.push(range);\n  });\n  return ranges;\n};\n\nGetSelectionProto.setSingleRange = function (range) {\n  this.removeAllRanges();\n  this.addRange(range);\n};\n\nfunction createControlSelection (sel, ranges) {\n  var controlRange = body.createControlRange();\n  for (var i = 0, el, len = ranges.length; i < len; ++i) {\n    el = getSingleElementFromRange(ranges[i]);\n    try {\n      controlRange.add(el);\n    } catch (e) {\n      throw new Error('setRanges(): Element could not be added to control selection');\n    }\n  }\n  controlRange.select();\n  updateControlSelection(sel);\n}\n\nfunction removeRangeManually (sel, range) {\n  var ranges = sel.getAllRanges();\n  sel.removeAllRanges();\n  for (var i = 0, len = ranges.length; i < len; ++i) {\n    if (!isSameRange(range, ranges[i])) {\n      sel.addRange(ranges[i]);\n    }\n  }\n  if (!sel.rangeCount) {\n    updateEmptySelection(sel);\n  }\n}\n\nfunction updateAnchorAndFocusFromRange (sel, range) {\n  var anchorPrefix = 'start';\n  var focusPrefix = 'end';\n  sel.anchorNode = range[anchorPrefix + 'Container'];\n  sel.anchorOffset = range[anchorPrefix + 'Offset'];\n  sel.focusNode = range[focusPrefix + 'Container'];\n  sel.focusOffset = range[focusPrefix + 'Offset'];\n}\n\nfunction updateEmptySelection (sel) {\n  sel.anchorNode = sel.focusNode = null;\n  sel.anchorOffset = sel.focusOffset = 0;\n  sel.rangeCount = 0;\n  sel.isCollapsed = true;\n  sel._ranges.length = 0;\n}\n\nfunction rangeContainsSingleElement (rangeNodes) {\n  if (!rangeNodes.length || rangeNodes[0].nodeType !== 1) {\n    return false;\n  }\n  for (var i = 1, len = rangeNodes.length; i < len; ++i) {\n    if (!isAncestorOf(rangeNodes[0], rangeNodes[i])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction getSingleElementFromRange (range) {\n  var nodes = range.getNodes();\n  if (!rangeContainsSingleElement(nodes)) {\n    throw new Error('getSingleElementFromRange(): range did not consist of a single element');\n  }\n  return nodes[0];\n}\n\nfunction isTextRange (range) {\n  return range && range.text !== void 0;\n}\n\nfunction updateFromTextRange (sel, range) {\n  sel._ranges = [range];\n  updateAnchorAndFocusFromRange(sel, range, false);\n  sel.rangeCount = 1;\n  sel.isCollapsed = range.collapsed;\n}\n\nfunction updateControlSelection (sel) {\n  sel._ranges.length = 0;\n  if (sel._selection.type === 'None') {\n    updateEmptySelection(sel);\n  } else {\n    var controlRange = sel._selection.createRange();\n    if (isTextRange(controlRange)) {\n      updateFromTextRange(sel, controlRange);\n    } else {\n      sel.rangeCount = controlRange.length;\n      var range;\n      for (var i = 0; i < sel.rangeCount; ++i) {\n        range = doc.createRange();\n        range.selectNode(controlRange.item(i));\n        sel._ranges.push(range);\n      }\n      sel.isCollapsed = sel.rangeCount === 1 && sel._ranges[0].collapsed;\n      updateAnchorAndFocusFromRange(sel, sel._ranges[sel.rangeCount - 1], false);\n    }\n  }\n}\n\nfunction addRangeToControlSelection (sel, range) {\n  var controlRange = sel._selection.createRange();\n  var rangeElement = getSingleElementFromRange(range);\n  var newControlRange = body.createControlRange();\n  for (var i = 0, len = controlRange.length; i < len; ++i) {\n    newControlRange.add(controlRange.item(i));\n  }\n  try {\n    newControlRange.add(rangeElement);\n  } catch (e) {\n    throw new Error('addRange(): Element could not be added to control selection');\n  }\n  newControlRange.select();\n  updateControlSelection(sel);\n}\n\nfunction isSameRange (left, right) {\n  return (\n    left.startContainer === right.startContainer &&\n    left.startOffset === right.startOffset &&\n    left.endContainer === right.endContainer &&\n    left.endOffset === right.endOffset\n  );\n}\n\nfunction isAncestorOf (ancestor, descendant) {\n  var node = descendant;\n  while (node.parentNode) {\n    if (node.parentNode === ancestor) {\n      return true;\n    }\n    node = node.parentNode;\n  }\n  return false;\n}\n\nfunction getSelection () {\n  return new GetSelection(global.document.selection);\n}\n\nmodule.exports = getSelection;\n","'use strict';\n\nfunction isHostMethod (host, prop) {\n  var type = typeof host[prop];\n  return type === 'function' || !!(type === 'object' && host[prop]) || type === 'unknown';\n}\n\nfunction isHostProperty (host, prop) {\n  return typeof host[prop] !== 'undefined';\n}\n\nfunction many (fn) {\n  return function areHosted (host, props) {\n    var i = props.length;\n    while (i--) {\n      if (!fn(host, props[i])) {\n        return false;\n      }\n    }\n    return true;\n  };\n}\n\nmodule.exports = {\n  method: isHostMethod,\n  methods: many(isHostMethod),\n  property: isHostProperty,\n  properties: many(isHostProperty)\n};\n","'use strict';\n\nvar doc = global.document;\nvar body = doc.body;\n\nfunction rangeToTextRange (p) {\n  if (p.collapsed) {\n    return createBoundaryTextRange({ node: p.startContainer, offset: p.startOffset }, true);\n  }\n  var startRange = createBoundaryTextRange({ node: p.startContainer, offset: p.startOffset }, true);\n  var endRange = createBoundaryTextRange({ node: p.endContainer, offset: p.endOffset }, false);\n  var textRange = body.createTextRange();\n  textRange.setEndPoint('StartToStart', startRange);\n  textRange.setEndPoint('EndToEnd', endRange);\n  return textRange;\n}\n\nfunction isCharacterDataNode (node) {\n  var t = node.nodeType;\n  return t === 3 || t === 4 || t === 8 ;\n}\n\nfunction createBoundaryTextRange (p, starting) {\n  var bound;\n  var parent;\n  var offset = p.offset;\n  var workingNode;\n  var childNodes;\n  var range = body.createTextRange();\n  var data = isCharacterDataNode(p.node);\n\n  if (data) {\n    bound = p.node;\n    parent = bound.parentNode;\n  } else {\n    childNodes = p.node.childNodes;\n    bound = offset < childNodes.length ? childNodes[offset] : null;\n    parent = p.node;\n  }\n\n  workingNode = doc.createElement('span');\n  workingNode.innerHTML = '&#feff;';\n\n  if (bound) {\n    parent.insertBefore(workingNode, bound);\n  } else {\n    parent.appendChild(workingNode);\n  }\n\n  range.moveToElementText(workingNode);\n  range.collapse(!starting);\n  parent.removeChild(workingNode);\n\n  if (data) {\n    range[starting ? 'moveStart' : 'moveEnd']('character', offset);\n  }\n  return range;\n}\n\nmodule.exports = rangeToTextRange;\n","'use strict';\n\nvar getSelection = require('./getSelection');\nvar setSelection = require('./setSelection');\n\nmodule.exports = {\n  get: getSelection,\n  set: setSelection\n};\n","'use strict';\n\nvar getSelection = require('./getSelection');\nvar rangeToTextRange = require('./rangeToTextRange');\nvar doc = global.document;\n\nfunction setSelection (p) {\n  if (doc.createRange) {\n    modernSelection();\n  } else {\n    oldSelection();\n  }\n\n  function modernSelection () {\n    var sel = getSelection();\n    var range = doc.createRange();\n    if (!p.startContainer) {\n      return;\n    }\n    if (p.endContainer) {\n      range.setEnd(p.endContainer, p.endOffset);\n    } else {\n      range.setEnd(p.startContainer, p.startOffset);\n    }\n    range.setStart(p.startContainer, p.startOffset);\n    sel.removeAllRanges();\n    sel.addRange(range);\n  }\n\n  function oldSelection () {\n    rangeToTextRange(p).select();\n  }\n}\n\nmodule.exports = setSelection;\n","'use strict';\n\nvar get = easyGet;\nvar set = easySet;\n\nif (document.selection && document.selection.createRange) {\n  get = hardGet;\n  set = hardSet;\n}\n\nfunction easyGet (el) {\n  return {\n    start: el.selectionStart,\n    end: el.selectionEnd\n  };\n}\n\nfunction hardGet (el) {\n  var active = document.activeElement;\n  if (active !== el) {\n    el.focus();\n  }\n\n  var range = document.selection.createRange();\n  var bookmark = range.getBookmark();\n  var original = el.value;\n  var marker = getUniqueMarker(original);\n  var parent = range.parentElement();\n  if (parent === null || !inputs(parent)) {\n    return result(0, 0);\n  }\n  range.text = marker + range.text + marker;\n\n  var contents = el.value;\n\n  el.value = original;\n  range.moveToBookmark(bookmark);\n  range.select();\n\n  return result(contents.indexOf(marker), contents.lastIndexOf(marker) - marker.length);\n\n  function result (start, end) {\n    if (active !== el) { // don't disrupt pre-existing state\n      if (active) {\n        active.focus();\n      } else {\n        el.blur();\n      }\n    }\n    return { start: start, end: end };\n  }\n}\n\nfunction getUniqueMarker (contents) {\n  var marker;\n  do {\n    marker = '@@marker.' + Math.random() * new Date();\n  } while (contents.indexOf(marker) !== -1);\n  return marker;\n}\n\nfunction inputs (el) {\n  return ((el.tagName === 'INPUT' && el.type === 'text') || el.tagName === 'TEXTAREA');\n}\n\nfunction easySet (el, p) {\n  el.selectionStart = parse(el, p.start);\n  el.selectionEnd = parse(el, p.end);\n}\n\nfunction hardSet (el, p) {\n  var range = el.createTextRange();\n\n  if (p.start === 'end' && p.end === 'end') {\n    range.collapse(false);\n    range.select();\n  } else {\n    range.collapse(true);\n    range.moveEnd('character', parse(el, p.end));\n    range.moveStart('character', parse(el, p.start));\n    range.select();\n  }\n}\n\nfunction parse (el, value) {\n  return value === 'end' ? el.value.length : value || 0;\n}\n\nfunction sell (el, p) {\n  if (arguments.length === 2) {\n    set(el, p);\n  }\n  return get(el);\n}\n\nmodule.exports = sell;\n","var si = typeof setImmediate === 'function', tick;\nif (si) {\n  tick = function (fn) { setImmediate(fn); };\n} else {\n  tick = function (fn) { setTimeout(fn, 0); };\n}\n\nmodule.exports = tick;"]}