@hestia-earth/ui-components 0.0.9 → 0.0.12

package/esm2015/tags-input/index.js

@@ -0,0 +1,1053 @@
+/* eslint-disable */
+import Component from './utils/component';
+import { cloneAttributes } from './utils/dom';
+import { isString, BooleanParse, isObject, isPromise, isFunction } from './utils/type';
+import defaultOptions from './defaultOptions';
+import tagTemplate from './templates/tag';
+import containerTemplate from './templates/wrapper';
+import dropdownItemTemplate from './templates/dropdown-item';
+// TODO: add pattern or function to valdiate value before adding
+export default class BulmaTagsInput extends Component {
+    constructor(element, options = {}) {
+        super(element, options, defaultOptions);
+        // Convert Boolean string options to full Boolean
+        this.options.allowDuplicates = BooleanParse(this.options.allowDuplicates);
+        this.options.caseSensitive = BooleanParse(this.options.caseSensitive);
+        this.options.clearSelectionOnTyping = BooleanParse(this.options.clearSelectionOnTyping);
+        this.options.closeDropdownOnItemSelect = BooleanParse(this.options.closeDropdownOnItemSelect);
+        this.options.freeInput = BooleanParse(this.options.freeInput);
+        this.options.highlightDuplicate = BooleanParse(this.options.highlightDuplicate);
+        this.options.highlightMatchesString = BooleanParse(this.options.highlightMatchesString);
+        this.options.removable = BooleanParse(this.options.removable);
+        this.options.searchOn = this.options.searchOn.toLowerCase();
+        this.options.selectable = BooleanParse(this.options.selectable);
+        this.options.trim = BooleanParse(this.options.trim);
+        //Bind events to current class
+        this._onDocumentClick = this._onDocumentClick.bind(this);
+        this._onInputChange = this._onInputChange.bind(this);
+        this._onInputClick = this._onInputClick.bind(this);
+        this._onInputFocusOut = this._onInputFocusOut.bind(this);
+        this._onInputFocusIn = this._onInputFocusIn.bind(this);
+        this._onInputKeyDown = this._onInputKeyDown.bind(this);
+        this._onInputKeyPress = this._onInputKeyPress.bind(this);
+        this._onOriginalInputChange = this._onOriginalInputChange.bind(this);
+        this._onTagDeleteClick = this._onTagDeleteClick.bind(this);
+        this._onTagClick = this._onTagClick.bind(this);
+        this._onDropdownItemClick = this._onDropdownItemClick.bind(this);
+        // Define internal variables
+        this._items = [];
+        this._selected = -1; // index of selected item
+        // Initiate plugin
+        this._init();
+    }
+    /**
+     * Initiate all DOM element corresponding to selector
+     *
+     * @method
+     * @return Array of all Plugin instances
+     */
+    static attach(selector = 'input[data-type="tags"], input[type="tags"], select[data-type="tags"], select[type="tags"]', options = {}, container = null) {
+        return super.attach(selector, options, container);
+    }
+    /**
+     * Initiate plugin
+     *
+     * @method init
+     * @return
+     */
+    _init() {
+        // Detect if original input was a Select element
+        this._isSelect = (this.element.tagName === 'SELECT');
+        this._isMultiple = (this._isSelect && this.element.hasAttribute('multiple'));
+        // Detect if we work with Object items or not
+        // Object Items is forced when working with select element
+        this._objectItems = (typeof this.options.itemValue !== 'undefined') || this._isSelect;
+        this.options.itemValue = this.options.itemValue ? this.options.itemValue : (this._isSelect ? 'value' : undefined);
+        this.options.itemText = this.options.itemText ? this.options.itemText : (this._isSelect ? 'text' : undefined);
+        // If no itemText pass then use itemValue as itemText
+        if (typeof this.options.itemText === 'undefined') {
+            this.options.itemText = this.options.itemValue;
+        }
+        // Force freeInput to False if working with object items
+        this.options.freeInput = this._objectItems ? false : this.options.freeInput;
+        // Init search engine
+        this.source = null;
+        if (typeof this.options.source !== 'undefined') {
+            // Fix searchOn option if wrong
+            if (!['value', 'text'].includes(this.options.searchOn)) {
+                this.options.searchOn = defaultOptions.searchOn;
+            }
+            if (isPromise(this.options.source)) {
+                this.source = this.options.source;
+            }
+            else if (isFunction(this.options.source)) {
+                this.source = value => Promise.resolve(this.options.source(value));
+            }
+            else if (Array.isArray(this.options.source)) {
+                this.source = value => Promise.resolve(this.options.source.filter(i => {
+                    const val = (this._objectItems ? i[this.options.itemValue] : i);
+                    return this.options.caseSensitive ? val.includes(value) : val.toLowerCase().includes(value.toLowerCase());
+                }));
+            }
+        }
+        // Determine allowed input modes
+        this._manualInputAllowed = !this._isSelect && this.options.freeInput;
+        this._filterInputAllowed = this._isSelect || this.source;
+        this._build();
+    }
+    /**
+     * Build TagsInput DOM elements
+     */
+    _build() {
+        // Create TagsInput DOM
+        const containerFragment = document.createRange().createContextualFragment(containerTemplate({
+            emptyTitle: typeof this.options.noResultsLabel !== 'undefined' ? this.options.noResultsLabel : 'No results found',
+            placeholder: this.element.placeholder ? this.element.placeholder : this.options.placeholder,
+            uuid: this.id
+        }));
+        this.container = containerFragment.firstElementChild;
+        this._input = this.container.querySelector('input');
+        this.dropdown = this.container.querySelector(`#${this.id}-list .dropdown-content`);
+        this.dropdownEmptyOption = this.dropdown.querySelector('.empty-title');
+        // Clone attributes between original and new input
+        cloneAttributes(this._input, this.element, 'data-type multiple name type value');
+        if (this.element.disabled) {
+            this.container.setAttribute('disabled', 'disabled');
+            this.options.removable = false;
+            this.options.selectable = false;
+        }
+        // Propagate original input disabled attribute to the container
+        if (this._input.getAttribute('disabled') || this._input.classList.contains('is-disabled')) {
+            this.container.setAttribute('disabled', 'disabled');
+        }
+        if (!this._manualInputAllowed) {
+            this.container.classList.add(this._filterInputAllowed ? 'is-filter' : 'no-input');
+        }
+        // Remove dropdown if no source or original input is not a select element
+        if (!this._isSelect && typeof this.options.source === 'undefined') {
+            this.dropdown.remove();
+            this.dropdown = null;
+            this._input.setAttribute('list', null);
+        }
+        // Initialize plugin value from original input value
+        if (this._isSelect) {
+            Array.from(this.element.options).forEach((option) => {
+                if (option.selected) {
+                    // HTML Option element contains value and text properties
+                    // Add it silently to not propagate to the original element
+                    this.add(option.value ? option : {
+                        value: option.text,
+                        text: option.text
+                    }, true);
+                }
+                this._createDropdownItem(option);
+            });
+        }
+        else {
+            // We have on input element
+            if (this.element.value.length) {
+                this.add(this._objectItems ? JSON.parse(this.element.value) : this.element.value, true);
+            }
+        }
+        this._bindEvents();
+        // Insert container right before original input and make original input hidden
+        this.element.parentNode.insertBefore(this.container, this.element);
+        // Hide original input (type="hidden" only works on select)
+        this.element.style.display = 'none';
+    }
+    /**
+     * Bind all events listener
+     */
+    _bindEvents() {
+        // Bind document click event to close dropdown
+        document.addEventListener('click', this._onDocumentClick);
+        // Bind event handlers to orginal input
+        this.element.addEventListener('change', this._onOriginalInputChange);
+        // Bind event handlers to internal input
+        this._input.addEventListener('input', this._onInputChange);
+        this._input.addEventListener('click', this._onInputClick);
+        this._input.addEventListener('keydown', this._onInputKeyDown);
+        this._input.addEventListener('keypress', this._onInputKeyPress);
+        this._input.addEventListener('focusout', this._onInputFocusOut);
+        this._input.addEventListener('focusin', this._onInputFocusIn);
+    }
+    /**
+     * Check if caret is at the beginning of the input value
+     */
+    _caretAtStart() {
+        try {
+            return this._input.selectionStart === 0 && this._input.selectionEnd === 0;
+        }
+        catch (e) {
+            return this._input.value === '';
+        }
+    }
+    /**
+     * Check value length constraint if option activated
+     *
+     * @param item
+     */
+    _checkLength(item) {
+        const value = this._objectItems ? item[this.options.itemValue] : item;
+        if (!isString(value)) {
+            return true;
+        }
+        return value.length >= this.options.minChars && (typeof this.options.maxChars === 'undefined' || value.length <= this.options.maxChars);
+    }
+    /**
+     * Close dropdown
+     */
+    _closeDropdown() {
+        if (this.dropdown) {
+            this.emit('before.dropdown.close', this);
+            this.container.classList.remove('is-active');
+            this.emit('after.dropdown.close', this);
+        }
+    }
+    /**
+     * Create a new dropdown item based on given item data
+     *
+     * @param item
+     */
+    _createDropdownItem(item) {
+        if (this.dropdown) {
+            // TODO: add possibility to provide template through options
+            const dropdownItemFragment = document.createRange().createContextualFragment(dropdownItemTemplate({
+                text: item.text,
+                value: item.value
+            }));
+            const dropdownItem = dropdownItemFragment.firstElementChild;
+            // Save item data into dataset
+            dropdownItem.dataset.value = item.value;
+            dropdownItem.dataset.text = item.text;
+            dropdownItem.addEventListener('click', this._onDropdownItemClick);
+            this.dropdown.append(dropdownItem);
+        }
+    }
+    /**
+     * Create a new tag and add it to the DOM
+     *
+     * @param string value
+     */
+    _createTag(item) {
+        const tagFragment = document.createRange().createContextualFragment(tagTemplate({
+            removable: this.options.removable,
+            style: this.options.tagClass,
+            text: item.text,
+            value: item.value
+        }));
+        const tag = tagFragment.firstElementChild;
+        // Attach tag click event to select it
+        tag.addEventListener('click', this._onTagClick);
+        if (this.options.removable) {
+            // Find delete button and attach click event
+            const deleteButton = tag.querySelector('.delete');
+            if (deleteButton) {
+                deleteButton.addEventListener('click', this._onTagDeleteClick);
+            }
+        }
+        // insert new tag at the end (ie just before input)
+        this.container.insertBefore(tag, this._input);
+    }
+    /**
+     * Remove all dropdown items except the empty title
+     */
+    _emptyDropdown() {
+        if (this.dropdown) {
+            Array.from(this.dropdown.children).filter((child) => !child.classList.contains('empty-title')).forEach((child) => {
+                child.remove();
+            });
+        }
+    }
+    /**
+     * Find needle into a string and wrap it with <mark> HTML tag
+     *
+     * @param string
+     * @param needle
+     */
+    _highlightMatchesInString(string, needle) {
+        const reg = '(' + needle + ')(?![^<]*>|[^<>]*</)'; // explanation: http://stackoverflow.com/a/18622606/1147859
+        const regex = new RegExp(reg, 'i');
+        // If the regex doesn't match the string just return initial string
+        if (!string.match(regex)) {
+            return string;
+        }
+        // Otherwise, get to highlighting
+        const matchStartPosition = string.match(regex).index;
+        const matchEndPosition = matchStartPosition + string.match(regex)[0].toString().length;
+        const originalTextFoundByRegex = string.substring(matchStartPosition, matchEndPosition);
+        string = string.replace(regex, `<mark class="is-highlighted">${originalTextFoundByRegex}</mark>`);
+        return string;
+    }
+    /**
+     * Open dropdown
+     */
+    _openDropdown() {
+        if (this.dropdown) {
+            this.container.classList.add('is-active');
+        }
+    }
+    /**
+     * Propagate internal input changes to the original input
+     */
+    _propagateChange() {
+        if (!this._isSelect) {
+            // If original element is an input element
+            this.element.value = this.value;
+        }
+        else {
+            // If original element is a select element
+            Array.from(this.element.options).forEach((option) => {
+                option.setAttribute('selected', undefined);
+                option.selected = false;
+                // If option has been added by TagsInput then we remove it
+                // Otherwise it is an original option
+                if (typeof option.dataset.source !== 'undefined') {
+                    option.remove();
+                }
+            });
+            // Update original element options selected attributes
+            this._items.forEach(item => {
+                this._updateSelectOptions({
+                    value: this._objectItems ? item[this.options.itemValue] : item,
+                    text: this._objectItems ? item[this.options.itemText] : item
+                });
+            });
+        }
+        // Trigger Change event manually (because original input is now hidden)
+        // Trick: Passes current class constructor name to prevent loop with _onOriginalInputChange handler)
+        const changeEvent = new CustomEvent('change', {
+            detail: this.constructor.name
+        });
+        this.element.dispatchEvent(changeEvent);
+    }
+    /**
+     * Trim value if option activated
+     *
+     * @param item
+     */
+    _trim(item) {
+        if (this.options.trim) {
+            if (this._objectItems) {
+                if (isString(item[this.options.itemValue])) {
+                    item[this.options.itemValue] = item[this.options.itemValue].trim();
+                }
+                if (isString(item[this.options.itemText])) {
+                    item[this.options.itemText] = item[this.options.itemText].trim();
+                }
+            }
+            else {
+                item = item.trim();
+            }
+        }
+        return item;
+    }
+    /**
+     * Filter Dropdown items to be compliant with already selected items and current input value
+     * Filtering is made on Text by default (can be changed with option)
+     */
+    _filterDropdownItems(value = null) {
+        if (this.dropdown) {
+            if (this.emit('before.dropdown.filter', this)) {
+                Array.from(this.dropdown.children).filter((child) => !child.classList.contains('empty-title')).forEach((child) => {
+                    const childValue = child.dataset[this.options.searchOn];
+                    // Remove highlights
+                    if (this.options.highlightMatchesString) {
+                        child.textContent = child.textContent.replace(/<\/?(mark\s?(class="is\-highlighted")?)?>]*>?/gm, '');
+                    }
+                    // If value is found in dropdown
+                    if ((value && value.length)) {
+                        if (this.options.caseSensitive) {
+                            child.style.display = childValue.includes(value) ? 'block' : 'none';
+                        }
+                        else {
+                            child.style.display = childValue.toLowerCase().includes(value.toLowerCase()) ? 'block' : 'none';
+                        }
+                        if (this.options.highlightMatchesString) {
+                            child.innerHTML = this._highlightMatchesInString(child.innerHTML, value);
+                        }
+                    }
+                    else {
+                        child.style.display = 'block';
+                    }
+                    if (!this.options.allowDuplicates || (this._isSelect && !this._isMultiple)) {
+                        const hasValue = this.options.searchOn === 'value' ? this.hasValue(childValue) : this.hasText(childValue);
+                        child.style.display = hasValue ? 'none' : child.style.display;
+                    }
+                });
+                const hasActiveItems = Array.from(this.dropdown.children).filter((child) => !child.classList.contains('empty-title')).some((child) => child.style.display !== 'none');
+                if (hasActiveItems) {
+                    this.dropdownEmptyOption.style.display = 'none';
+                }
+                else {
+                    this.dropdownEmptyOption.style.display = 'block';
+                }
+                this.emit('after.dropdown.filter', this);
+                return hasActiveItems;
+            }
+        }
+        return true;
+    }
+    /**
+     * Update original select option based on given item
+     *
+     * @param item
+     */
+    _updateSelectOptions(item) {
+        if (this._isSelect) {
+            // Check to see if the tag exists in its raw or uri-encoded form
+            let option = this.element.querySelector(`option[value="${encodeURIComponent(item.value)}"]`) || this.element.querySelector(`option[value="${item.value}"]`);
+            // add <option /> if item represents a value not present in one of the <select />'s options
+            if (!option) {
+                const optionFragment = document.createRange().createContextualFragment(`<option value="${item.value}" data-source="${this.id}" selected>${item.text}</option>`);
+                option = optionFragment.firstElementChild;
+                this.element.add(option);
+            }
+            // mark option as selected
+            option.setAttribute('selected', 'selected');
+            option.selected = true;
+        }
+    }
+    /**
+     * Add given item
+     * item = 'john'
+     * item = 'john,jane'
+     * item = ['john', 'jane']
+     * item = [{
+     *  "value": "1",
+     *  "text": "John"
+     * }, {
+     *  "value": "2",
+     *  "text": "Jane"
+     * }]
+     *
+     * @param item
+     * @param silently Should the change be propagated to the original element
+     */
+    add(items, silently = false) {
+        // Check if number of items is limited ans reached
+        if (typeof this.options.maxTags !== 'undefined' && this._items.length >= this.options.maxTags) {
+            return this;
+        }
+        // Make sure to work with an array of items
+        items = Array.isArray(items) ? items : isObject(items) ? [items] : items.split(this.options.delimiter);
+        // If string items are expected then check every item is a string
+        if (!this._objectItems && (items.filter(item => isString(item)).length !== items.length)) {
+            throw ('Item must be a string or an array of strings');
+        }
+        // If object items are expected then check every item is an object
+        if (this._objectItems && (items.filter(item => isObject(item)).length !== items.length)) {
+            throw ('Item must be an object or an array of objects');
+        }
+        items.forEach(item => {
+            item = this._trim(item);
+            // Check if item respects min/max chars
+            if (this._checkLength(item)) {
+                // If original input is a non multiple select element
+                if (this._isSelect && !this._isMultiple && this._items.length > 0) {
+                    this.removeAtIndex(0);
+                    this.element.remove(this.element.selectedIndex);
+                }
+                // check if duplicates are allowed or not
+                if (item = this.emit('before.add', item)) {
+                    if (this.options.allowDuplicates || !this.has(item)) {
+                        const itemData = {
+                            value: this._objectItems ? item[this.options.itemValue] : item,
+                            text: this._objectItems ? item[this.options.itemText] : item
+                        };
+                        const tag = this._createTag(itemData);
+                        // save item into the internal array
+                        this._items.push(item);
+                        if (!silently) {
+                            // Propagate change event to the original input
+                            this._propagateChange();
+                            this.emit('after.add', {
+                                item,
+                                tag
+                            });
+                        }
+                    }
+                    else {
+                        if (this.options.highlightDuplicate) {
+                            const duplicateTag = Array.from(this.container.children).filter((child) => child.classList.contains('tag'))[this.indexOf(item)];
+                            if (duplicateTag) {
+                                duplicateTag.classList.add('is-duplicate');
+                                setTimeout(() => {
+                                    duplicateTag.classList.remove('is-duplicate');
+                                }, 1250);
+                            }
+                        }
+                        this.emit('item.duplicate', item);
+                    }
+                }
+            }
+        });
+        return this;
+    }
+    /**
+     * Unselect the selected item
+     */
+    clearSelection() {
+        if (this._selected >= 0) {
+            const item = this._items[this._selected];
+            const tag = Array.from(this.container.children).filter((child) => child.classList.contains('tag'))[this._selected];
+            if (this.emit('before.unselect', {
+                item,
+                tag
+            })) {
+                if (tag) {
+                    tag.classList.remove('is-selected');
+                }
+                this._selected = -1;
+                this.emit('after.unselect', {
+                    item,
+                    tag
+                });
+            }
+        }
+        return this;
+    }
+    /**
+     * Shortcut to removeAll method
+     */
+    flush() {
+        return this.removeAll();
+    }
+    /**
+     * Sets focus on the input
+     */
+    focus() {
+        this.container.classList.add('is-focused');
+        this._input.focus();
+        return this;
+    }
+    /**
+     * Check if given item is present
+     *
+     * @param item
+     */
+    has(item) {
+        item = this._trim(item);
+        if (this._objectItems) {
+            return this._items.some(i => this.options.caseSensitive || !isString(i[this.options.itemValue]) ? i[this.options.itemValue] === item[this.options.itemValue] : i[this.options.itemValue].toLowerCase() === item[this.options.itemValue].toLowerCase());
+        }
+        else {
+            return this.hasValue(item);
+        }
+    }
+    /**
+     * Check if given text is present
+     *
+     * @param value
+     */
+    hasText(value) {
+        if (this.options.trim) {
+            value = value.trim();
+        }
+        return this._items.some(i => {
+            const val = (this._objectItems ? i[this.options.itemText] : i);
+            return this.options.caseSensitive ? val === value : val.toLowerCase() === value.toLowerCase();
+        });
+    }
+    /**
+     * Check if given value is present
+     *
+     * @param value
+     */
+    hasValue(value) {
+        if (this.options.trim) {
+            value = value.trim();
+        }
+        return this._items.some(i => {
+            const val = (this._objectItems ? i[this.options.itemValue] : i);
+            return this.options.caseSensitive ? val === value : val.toLowerCase() === value.toLowerCase();
+        });
+    }
+    /**
+     * Get index of given item
+     *
+     * @param item
+     */
+    indexOf(item) {
+        item = this._trim(item);
+        if (this._objectItems) {
+            if (!isObject(item)) {
+                throw ('Item must be an object');
+            }
+            return this._items.map(function (e) { return e.value; }).indexOf(item.value);
+        }
+        else {
+            return this._items.indexOf(item);
+        }
+    }
+    /**
+     * Returns the internal input element
+     */
+    input() {
+        return this._input;
+    }
+    /**
+     * Get items
+     */
+    items() {
+        return this._items;
+    }
+    /**
+     * Remove given item
+     * item = 'john'
+     * item = 'john,jane'
+     *
+     * @param String item
+     */
+    remove(items) {
+        if (this.options.removable) {
+            // Make sure to work with an array of items
+            items = Array.isArray(items) ? items : isObject(items) ? [items] : items.split(this.options.delimiter);
+            // If string items are expected then check every item is a string
+            if (!this._objectItems && (items.filter(item => isString(item)).length !== items.length)) {
+                throw ('Item must be a string or an array of strings');
+            }
+            // If object items are expected then check every item is an object
+            if (this._objectItems && (items.filter(item => isObject(item)).length !== items.length)) {
+                throw ('Item must be an object or an array of objects');
+            }
+            items.forEach(item => {
+                let index = this.indexOf(item);
+                while (index >= 0) {
+                    this.removeAtIndex(index);
+                    index = this.indexOf(item);
+                }
+            });
+        }
+        return this;
+    }
+    /**
+     * Remove all tags at once
+     */
+    removeAll() {
+        if (this.options.removable) {
+            if (this.emit('before.flush', this._items)) {
+                this.clearSelection();
+                Array.from(this.container.children).filter((child) => child.classList.contains('tag')).forEach((tag) => tag.remove());
+                this._items = [];
+                this._filterDropdownItems();
+                this._propagateChange();
+                this.emit('after.flush', this._items);
+            }
+        }
+        return this;
+    }
+    /**
+     * Remove item at given index
+     *
+     * @param Integer index
+     */
+    removeAtIndex(index, clearSelection = true) {
+        if (this.options.removable && !isNaN(index) && index >= 0 && index < this._items.length) {
+            const tag = Array.from(this.container.children).filter((child) => child.classList.contains('tag'))[index];
+            const item = this._items[index];
+            if (this.emit('before.remove', item)) {
+                if (clearSelection) {
+                    this.clearSelection();
+                }
+                if (tag) {
+                    tag.remove();
+                }
+                // If original input is a select element
+                // then deselect related option
+                if (this._isSelect) {
+                    this.element.options[index].selected = false;
+                }
+                if (this._selected == index) {
+                    this._selected = -1;
+                }
+                else if (this._selected >= 0) {
+                    // One item less so selected index is
+                    this._selected -= 1;
+                }
+                this._items.splice(index, 1);
+                this._filterDropdownItems();
+                this._propagateChange();
+                this.emit('after.remove', item);
+            }
+        }
+        return this;
+    }
+    /**
+     * Select given item
+     *
+     * @param item
+     */
+    select(items) {
+        if (this.options.selectable) {
+            // Make sure to work with an array of items
+            items = Array.isArray(items) ? items : isObject(items) ? [items] : items.split(this.options.delimiter);
+            // If string items are expected then check every item is a string
+            if (!this._objectItems && (items.filter(item => isString(item)).length !== items.length)) {
+                throw ('Item must be a string or an array of strings');
+            }
+            // If object items are expected then check every item is an object
+            if (this._objectItems && (items.filter(item => isObject(item)).length !== items.length)) {
+                throw ('Item must be an object or an array of objects');
+            }
+            items.forEach(item => {
+                this.selectAtIndex(this.indexOf(item));
+            });
+        }
+        return this;
+    }
+    /**
+     * Select tag at given index
+     *
+     * @param Integer index
+     */
+    selectAtIndex(index) {
+        if (this.options.selectable) {
+            // Clear selection
+            this.clearSelection();
+            if (!isNaN(index) && index >= 0 && index < this._items.length) {
+                const tag = Array.from(this.container.children).filter((child) => child.classList.contains('tag'))[index];
+                const item = this._items[index];
+                if (this.emit('before.select', {
+                    item,
+                    tag
+                })) {
+                    if (tag) {
+                        tag.classList.add('is-selected');
+                    }
+                    this._selected = index;
+                    this.emit('after.select', {
+                        item,
+                        tag
+                    });
+                }
+            }
+        }
+        return this;
+    }
+    /**
+     * Get selected item
+     */
+    get selected() {
+        if (this._selected >= 0) {
+            return this._items[this._selected];
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Get selected item index
+     */
+    get selectedIndex() {
+        return this._selected;
+    }
+    /**
+     * Get value
+     */
+    get value() {
+        if (!this._isSelect) {
+            if (this._objectItems) {
+                return this._items.map(item => item.value).join(this.options.delimiter);
+            }
+            else {
+                return this._items.join(this.options.delimiter);
+            }
+        }
+        else {
+            return Array.from(this.element.options).filter((option) => option.selected).map((option) => option.value);
+        }
+    }
+    /**
+     * Set value
+     */
+    set value(string) {
+        this.removeAll();
+        this.add(string);
+    }
+    /**
+     * Document click event handler
+     *
+     * @param e
+     */
+    _onDocumentClick(e) {
+        if (this.dropdown) {
+            // If we click on element inside container then do nothing
+            if (this.container.contains(e.target)) {
+                return;
+            }
+            // Tag and delete button already deleted when event triggered
+            // So we check if target is a tag delete button
+            if (e.target.dataset.tag && e.target.dataset.tag === 'delete') {
+                return;
+            }
+            // Click outside dropdown so close it
+            this._closeDropdown();
+        }
+    }
+    /**
+     * Input focus lost event handler
+     *
+     * @param e
+     */
+    _onDropdownItemClick(e) {
+        e.preventDefault();
+        if (this.dropdown) {
+            if (this._objectItems) {
+                const item = {};
+                item[this.options.itemText] = e.currentTarget.dataset.text;
+                item[this.options.itemValue] = e.currentTarget.dataset.value;
+                this.add(item);
+            }
+            else {
+                this.add(e.currentTarget.dataset.value);
+            }
+            this._filterDropdownItems();
+            this._input.value = '';
+            this._input.focus();
+            if (this.options.closeDropdownOnItemSelect) {
+                this._closeDropdown();
+            }
+        }
+    }
+    /**
+     * Input change event handler
+     *
+     * @param e
+     */
+    _onInputChange(e) {
+        this._filterDropdownItems(this._input.value);
+    }
+    /**
+     * Input click event handler
+     *
+     * @param e
+     */
+    _onInputClick(e) {
+        e.preventDefault();
+        if (!this.source || this._input.value.length >= this.options.searchMinChars) {
+            this._openDropdown();
+            this._filterDropdownItems();
+        }
+    }
+    /**
+     * Input focus event handler
+     *
+     * @param e
+     */
+    _onInputFocusIn(e) {
+        e.preventDefault();
+        if (this.container.getAttribute('disabled') !== null || this.container.classList.contains('is-disabled')) {
+            this._input.blur();
+            return false;
+        }
+        this.container.classList.add('is-focused');
+    }
+    /**
+     * Input focus lost event handler
+     *
+     * @param e
+     */
+    _onInputFocusOut(e) {
+        e.preventDefault();
+        this.container.classList.remove('is-focused');
+    }
+    /**
+     * Input Keydown event handler
+     *
+     * @param e
+     */
+    _onInputKeyDown(e) {
+        const key = e.charCode || e.keyCode || e.which;
+        switch (key) {
+            // BACKSPACE
+            case 8:
+                if (this.options.removable) {
+                    if (this._caretAtStart() && this._selected >= 0) {
+                        const currentItemIndex = this._selected;
+                        // If tag was selected then select next (or previous if next does not exists)
+                        if (currentItemIndex >= 0) {
+                            this.selectAtIndex(currentItemIndex + 1 < this._items.length ? currentItemIndex + 1 : currentItemIndex - 1);
+                        }
+                        this.removeAtIndex(currentItemIndex, false);
+                    }
+                }
+                if (this.source && (this._input.value.length) < this.options.searchMinChars) {
+                    this._closeDropdown();
+                }
+                break;
+            // ESCAPE
+            case 27:
+                if (this._selected >= 0) {
+                    this.clearSelection();
+                }
+                this._closeDropdown();
+                break;
+            // DELETE
+            case 46:
+                if (this.options.removable) {
+                    if (this._caretAtStart() && this._selected >= 0) {
+                        const currentItemIndex = this._selected;
+                        // If tag was selected then select next (or previous if next does not exists)
+                        if (currentItemIndex >= 0) {
+                            this.selectAtIndex(currentItemIndex + 1 < this._items.length ? currentItemIndex + 1 : currentItemIndex - 1);
+                        }
+                        this.removeAtIndex(currentItemIndex, false);
+                    }
+                }
+                if (this.source && (this._input.value.length) < this.options.searchMinChars) {
+                    this._closeDropdown();
+                }
+                break;
+            // LEFT ARROW
+            case 37:
+                if (!this._input.value.length) {
+                    if (this._selected < 0) {
+                        this.selectAtIndex(this._items.length - 1);
+                    }
+                    else {
+                        this.selectAtIndex(this._selected - 1 >= 0 ? this._selected - 1 : this._items.length - 1);
+                    }
+                }
+                break;
+            // RIGHT ARROW
+            case 39:
+                if (!this._input.value.length) {
+                    if (this._selected < 0) {
+                        this.selectAtIndex(0);
+                    }
+                    else {
+                        this.selectAtIndex(this._selected + 1 >= this._items.length ? 0 : this._selected + 1);
+                    }
+                }
+                break;
+            default:
+                if (this.options.clearSelectionOnTyping) {
+                    this.clearSelection();
+                }
+            // ignore
+        }
+    }
+    /**
+     * Input Keypress event handler
+     *
+     * @param e
+     */
+    _onInputKeyPress(e) {
+        const key = e.charCode || e.keyCode || e.which;
+        let value = this._trim(this._input.value) + String.fromCharCode(key);
+        if (!this._manualInputAllowed && !this._filterInputAllowed) {
+            e.preventDefault();
+            return false;
+        }
+        // ENTER
+        if (!value.length && key !== 13) {
+            return false;
+        }
+        if (this._filterInputAllowed) {
+            this._filterDropdownItems(value);
+        }
+        if (this._filterInputAllowed && this.source && value.length >= this.options.searchMinChars && key !== 13) {
+            this._openDropdown();
+            this.dropdown.classList.add('is-loading');
+            this._emptyDropdown();
+            this.source(value).then(results => {
+                results = this.emit('on.results.received', results);
+                if (results.length) {
+                    results.forEach(result => {
+                        const item = {
+                            value: null,
+                            text: null
+                        };
+                        if (!isObject(result)) {
+                            item.value = result;
+                            item.text = result;
+                        }
+                        else {
+                            item.value = result[this.options.itemValue];
+                            item.text = result[this.options.itemText];
+                        }
+                        this._createDropdownItem(item);
+                    });
+                }
+                this._filterDropdownItems(value);
+                this.dropdown.classList.remove('is-loading');
+            });
+        }
+        if (this._manualInputAllowed && (value.includes(this.options.delimiter) || key == 13)) {
+            // Prevent default behavior (ie: add char into input value)
+            e.preventDefault();
+            // Split value by delimiter in case we copy/paste multiple values
+            const values = value.split(this.options.delimiter);
+            values.forEach(value => {
+                // check if empty text when delimiter is removed
+                if ((value = value.replace(this.options.delimiter, '')) != '') {
+                    // push to array and remove delimiter
+                    this.add(value);
+                }
+            });
+            value = '';
+            // clear input
+            this._input.value = '';
+            this._closeDropdown();
+            return false;
+        }
+    }
+    /**
+     * Original input change event handler
+     * CAUTION: because original input is now hidden the change event must be triggered manually on change
+     * Example how to trigger change event manually
+     * var changeEvent = new Event('change');
+     * input.dispatchEvent(changeEvent);
+     *
+     * @param e
+     */
+    _onOriginalInputChange(e) {
+        if (!e.detail || isString(e.detail) && e.detail !== this.constructor.name) {
+            this.value = e.currentTarget.value;
+        }
+    }
+    /**
+     * Tag click event handler
+     *
+     * @param e
+     */
+    _onTagClick(e) {
+        e.preventDefault();
+        if (e.currentTarget.classList.contains('delete')) {
+            return false;
+        }
+        if (this.container.getAttribute('disabled') !== null || this.container.classList.contains('is-disabled')) {
+            return false;
+        }
+        this._input.focus();
+        if (this.options.selectable) {
+            const tag = e.currentTarget.closest('.tag');
+            if (tag) {
+                const tagIndex = Array.from(this.container.children).indexOf(tag);
+                if (tagIndex === this._selected) {
+                    this.clearSelection();
+                }
+                else {
+                    this.selectAtIndex(tagIndex);
+                }
+            }
+        }
+    }
+    /**
+     * Delete tag button click event handler
+     *
+     * @param e
+     */
+    _onTagDeleteClick(e) {
+        e.preventDefault();
+        if (this.container.getAttribute('disabled') !== null || this.container.classList.contains('is-disabled')) {
+            return false;
+        }
+        const tag = e.currentTarget.closest('.tag');
+        if (tag) {
+            this.removeAtIndex(Array.from(this.container.children).indexOf(tag));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/tags-input/index.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB,OAAO,SAAS,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACvF,OAAO,cAAc,MAAM,kBAAkB,CAAC;AAC9C,OAAO,WAAW,MAAM,iBAAiB,CAAC;AAC1C,OAAO,iBAAiB,MAAM,qBAAqB,CAAC;AACpD,OAAO,oBAAoB,MAAM,2BAA2B,CAAC;AAE7D,gEAAgE;AAEhE,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,SAAS;IAcnD,YAAY,OAAO,EAAE,OAAO,GAAG,EAAE;QAC/B,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,CAAC,CAAC;QAExC,iDAAiD;QACjD,IAAI,CAAC,OAAO,CAAC,eAAe,GAAG,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;QAC1E,IAAI,CAAC,OAAO,CAAC,aAAa,GAAG,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;QACtE,IAAI,CAAC,OAAO,CAAC,sBAAsB,GAAG,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC;QACxF,IAAI,CAAC,OAAO,CAAC,yBAAyB,GAAG,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,yBAAyB,CAAC,CAAC;QAC9F,IAAI,CAAC,OAAO,CAAC,SAAS,GAAG,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC9D,IAAI,CAAC,OAAO,CAAC,kBAAkB,GAAG,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;QAChF,IAAI,CAAC,OAAO,CAAC,sBAAsB,GAAG,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC;QACxF,IAAI,CAAC,OAAO,CAAC,SAAS,GAAG,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC9D,IAAI,CAAC,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QAC5D,IAAI,CAAC,OAAO,CAAC,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAChE,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAEpD,8BAA8B;QAC9B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrD,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzD,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvD,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzD,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrE,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3D,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/C,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEjE,4BAA4B;QAC5B,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;QACjB,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,yBAAyB;QAE9C,kBAAkB;QAClB,IAAI,CAAC,KAAK,EAAE,CAAC;IACf,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,QAAQ,GAAG,4FAA4F,EAAE,OAAO,GAAG,EAAE,EAAE,SAAS,GAAG,IAAI;QACnJ,OAAO,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;IACpD,CAAC;IAED;;;;;OAKG;IACH,KAAK;QACH,gDAAgD;QAChD,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC;QACrD,IAAI,CAAC,WAAW,GAAG,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC;QAE7E,6CAA6C;QAC7C,0DAA0D;QAC1D,IAAI,CAAC,YAAY,GAAG,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,KAAK,WAAW,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC;QACtF,IAAI,CAAC,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QAClH,IAAI,CAAC,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QAC9G,qDAAqD;QACrD,IAAI,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,KAAK,WAAW,EAAE;YAChD,IAAI,CAAC,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;SAChD;QAED,wDAAwD;QACxD,IAAI,CAAC,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;QAE5E,qBAAqB;QACrB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,WAAW,EAAE;YAC9C,+BAA+B;YAC/B,IAAI,CAAC,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;gBACtD,IAAI,CAAC,OAAO,CAAC,QAAQ,GAAG,cAAc,CAAC,QAAQ,CAAC;aACjD;YAED,IAAI,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;gBAClC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;aACnC;iBAAM,IAAI,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;gBAC1C,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;aACpE;iBAAM,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;gBAC7C,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;oBACpE,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBAEhE,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;gBAC5G,CAAC,CAAC,CAAC,CAAC;aACL;SACF;QAED,gCAAgC;QAChC,IAAI,CAAC,mBAAmB,GAAG,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;QACrE,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC;QAEzD,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,uBAAuB;QACvB,MAAM,iBAAiB,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC,wBAAwB,CAAC,iBAAiB,CAAC;YAC1F,UAAU,EAAE,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,KAAK,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,kBAAkB;YACjH,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW;YAC3F,IAAI,EAAE,IAAI,CAAC,EAAE;SACd,CAAC,CAAC,CAAC;QAEJ,IAAI,CAAC,SAAS,GAAG,iBAAiB,CAAC,iBAAiB,CAAC;QACrD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QACpD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,IAAI,CAAC,EAAE,yBAAyB,CAAC,CAAC;QACnF,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;QAEvE,kDAAkD;QAClD,eAAe,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,oCAAoC,CAAC,CAAC;QAEjF,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE;YACzB,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;YACpD,IAAI,CAAC,OAAO,CAAC,SAAS,GAAG,KAAK,CAAC;YAC/B,IAAI,CAAC,OAAO,CAAC,UAAU,GAAG,KAAK,CAAC;SACjC;QAED,+DAA+D;QAC/D,IAAI,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE;YACzF,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;SACrD;QAED,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE;YAC7B,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;SACnF;QAED,yEAAyE;QACzE,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,WAAW,EAAE;YACjE,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;YACvB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;SACxC;QAED,oDAAoD;QACpD,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,MAAW,EAAE,EAAE;gBACvD,IAAI,MAAM,CAAC,QAAQ,EAAE;oBACnB,yDAAyD;oBACzD,2DAA2D;oBAC3D,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;wBAC/B,KAAK,EAAE,MAAM,CAAC,IAAI;wBAClB,IAAI,EAAE,MAAM,CAAC,IAAI;qBAClB,EAAE,IAAI,CAAC,CAAC;iBACV;gBAED,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;YACnC,CAAC,CAAC,CAAC;SACJ;aAAM;YACL,2BAA2B;YAC3B,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE;gBAC7B,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;aACzF;SACF;QAED,IAAI,CAAC,WAAW,EAAE,CAAC;QAEnB,8EAA8E;QAC9E,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAEnE,2DAA2D;QAC3D,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,WAAW;QACT,8CAA8C;QAC9C,QAAQ,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAE1D,uCAAuC;QACvC,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,sBAAsB,CAAC,CAAC;QAErE,wCAAwC;QACxC,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAC3D,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;QAC1D,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;QAC9D,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAChE,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAChE,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;IAChE,CAAC;IAED;;OAEG;IACH,aAAa;QACX,IAAI;YACF,OAAO,IAAI,CAAC,MAAM,CAAC,cAAc,KAAK,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,YAAY,KAAK,CAAC,CAAC;SAC3E;QAAC,OAAO,CAAC,EAAE;YACV,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,KAAK,EAAE,CAAC;SACjC;IACH,CAAC;IAED;;;;OAIG;IACH,YAAY,CAAC,IAAI;QACf,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAEtE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;YACpB,OAAO,IAAI,CAAC;SACb;QAED,OAAO,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,KAAK,WAAW,IAAI,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC1I,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,CAAC,IAAI,CAAC,uBAAuB,EAAE,IAAI,CAAC,CAAC;YAEzC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;YAE7C,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,IAAI,CAAC,CAAC;SACzC;IACH,CAAC;IAED;;;;OAIG;IACH,mBAAmB,CAAC,IAAI;QACtB,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,4DAA4D;YAC5D,MAAM,oBAAoB,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC,wBAAwB,CAAC,oBAAoB,CAAC;gBAChG,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,KAAK,EAAE,IAAI,CAAC,KAAK;aAClB,CAAC,CAAC,CAAC;YACJ,MAAM,YAAY,GAAG,oBAAoB,CAAC,iBAAiB,CAAC;YAE5D,8BAA8B;YAC7B,YAAoB,CAAC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;YAChD,YAAoB,CAAC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;YAE/C,YAAa,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,oBAAoB,CAAC,CAAC;YAEnE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;SACpC;IACH,CAAC;IAED;;;;OAIG;IACH,UAAU,CAAC,IAAI;QACb,MAAM,WAAW,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC,wBAAwB,CAAC,WAAW,CAAC;YAC9E,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS;YACjC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ;YAC5B,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC,CAAC,CAAC;QACJ,MAAM,GAAG,GAAG,WAAW,CAAC,iBAAiB,CAAC;QAE1C,sCAAsC;QACtC,GAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAEjD,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE;YAC1B,4CAA4C;YAC5C,MAAM,YAAY,GAAG,GAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;YACnD,IAAI,YAAY,EAAE;gBAChB,YAAY,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;aAChE;SACF;QAED,mDAAmD;QACnD,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,KAAU,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KAAU,EAAE,EAAE;gBACzH,KAAK,CAAC,MAAM,EAAE,CAAC;YACjB,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IAED;;;;;OAKG;IACH,yBAAyB,CAAC,MAAM,EAAE,MAAM;QACtC,MAAM,GAAG,GAAG,GAAG,GAAG,MAAM,GAAG,sBAAsB,CAAC,CAAC,2DAA2D;QAC9G,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;QAEnC,mEAAmE;QACnE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;YACxB,OAAO,MAAM,CAAC;SACf;QAED,iCAAiC;QACjC,MAAM,kBAAkB,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC;QACrD,MAAM,gBAAgB,GAAG,kBAAkB,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC;QACvF,MAAM,wBAAwB,GAAG,MAAM,CAAC,SAAS,CAAC,kBAAkB,EAAE,gBAAgB,CAAC,CAAC;QACxF,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,gCAAgC,wBAAwB,SAAS,CAAC,CAAC;QAElG,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACH,aAAa;QACX,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;SAC3C;IACH,CAAC;IAED;;OAEG;IACH,gBAAgB;QACd,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACnB,0CAA0C;YAC1C,IAAI,CAAC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;SACjC;aAAM;YACL,0CAA0C;YAC1C,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,MAAW,EAAE,EAAE;gBACvD,MAAM,CAAC,YAAY,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;gBAC3C,MAAM,CAAC,QAAQ,GAAG,KAAK,CAAC;gBAExB,0DAA0D;gBAC1D,qCAAqC;gBACrC,IAAI,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,KAAK,WAAW,EAAE;oBAChD,MAAM,CAAC,MAAM,EAAE,CAAC;iBACjB;YACH,CAAC,CAAC,CAAC;YAEH,sDAAsD;YACtD,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBACzB,IAAI,CAAC,oBAAoB,CAAC;oBACxB,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI;oBAC9D,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI;iBAC7D,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;SACJ;QAED,uEAAuE;QACvE,oGAAoG;QACpG,MAAM,WAAW,GAAG,IAAI,WAAW,CAAC,QAAQ,EAAE;YAC5C,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI;SAC9B,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;IAC1C,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,IAAI;QACR,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE;YACrB,IAAI,IAAI,CAAC,YAAY,EAAE;gBACrB,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE;oBAC1C,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,CAAC;iBACpE;gBAED,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE;oBACzC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;iBAClE;aACF;iBAAM;gBACL,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;aACpB;SACF;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,oBAAoB,CAAC,QAAa,IAAI;QACpC,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,IAAI,CAAC,IAAI,CAAC,wBAAwB,EAAE,IAAI,CAAC,EAAE;gBAC7C,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,KAAU,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KAAU,EAAE,EAAE;oBACzH,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;oBAExD,oBAAoB;oBACpB,IAAI,IAAI,CAAC,OAAO,CAAC,sBAAsB,EAAE;wBACvC,KAAK,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC,OAAO,CAAC,iDAAiD,EAAE,EAAE,CAAC,CAAC;qBACtG;oBAED,gCAAgC;oBAChC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,CAAC,EAAE;wBAC3B,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE;4BAC9B,KAAK,CAAC,KAAK,CAAC,OAAO,GAAG,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;yBACrE;6BAAM;4BACL,KAAK,CAAC,KAAK,CAAC,OAAO,GAAG,UAAU,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;yBACjG;wBAED,IAAI,IAAI,CAAC,OAAO,CAAC,sBAAsB,EAAE;4BACvC,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,yBAAyB,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;yBAC1E;qBACF;yBAAM;wBACL,KAAK,CAAC,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;qBAC/B;oBAED,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;wBAC1E,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;wBAE1G,KAAK,CAAC,KAAK,CAAC,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC;qBAC/D;gBACH,CAAC,CAAC,CAAC;gBAEH,MAAM,cAAc,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,KAAU,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,KAAU,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC;gBAChL,IAAI,cAAc,EAAE;oBAClB,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;iBACjD;qBAAM;oBACL,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;iBAClD;gBAED,IAAI,CAAC,IAAI,CAAC,uBAAuB,EAAE,IAAI,CAAC,CAAC;gBAEzC,OAAO,cAAc,CAAC;aACvB;SACF;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,oBAAoB,CAAC,IAAI;QACvB,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,gEAAgE;YAChE,IAAI,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,iBAAiB,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,iBAAiB,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;YAE5J,2FAA2F;YAC3F,IAAI,CAAC,MAAM,EAAE;gBACX,MAAM,cAAc,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC,wBAAwB,CAAC,kBAAkB,IAAI,CAAC,KAAK,kBAAkB,IAAI,CAAC,EAAE,cAAc,IAAI,CAAC,IAAI,WAAW,CAAC,CAAC;gBAChK,MAAM,GAAG,cAAc,CAAC,iBAAiB,CAAC;gBAE1C,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;aAC1B;YAED,0BAA0B;YAC1B,MAAM,CAAC,YAAY,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;YAC5C,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC;SACxB;IACH,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,GAAG,CAAC,KAAK,EAAE,QAAQ,GAAG,KAAK;QACzB,kDAAkD;QAClD,IAAI,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,KAAK,WAAW,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE;YAC7F,OAAO,IAAI,CAAC;SACb;QAED,2CAA2C;QAC3C,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAEvG,iEAAiE;QACjE,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,CAAC,EAAE;YACxF,MAAM,CAAC,8CAA8C,CAAC,CAAC;SACxD;QAED,kEAAkE;QAClE,IAAI,IAAI,CAAC,YAAY,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,CAAC,EAAE;YACvF,MAAM,CAAC,+CAA+C,CAAC,CAAC;SACzD;QAED,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACnB,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAExB,uCAAuC;YACvC,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE;gBAE3B,qDAAqD;gBACrD,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;oBACjE,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;oBACtB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;iBACjD;gBAED,yCAAyC;gBACzC,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,EAAE;oBACxC,IAAI,IAAI,CAAC,OAAO,CAAC,eAAe,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;wBACnD,MAAM,QAAQ,GAAG;4BACf,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI;4BAC9D,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI;yBAC7D,CAAC;wBAEF,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;wBAEtC,oCAAoC;wBACpC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;wBAEvB,IAAI,CAAC,QAAQ,EAAE;4BACb,+CAA+C;4BAC/C,IAAI,CAAC,gBAAgB,EAAE,CAAC;4BAExB,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;gCACrB,IAAI;gCACJ,GAAG;6BACJ,CAAC,CAAC;yBACJ;qBACF;yBAAM;wBACL,IAAI,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE;4BACnC,MAAM,YAAY,GAAQ,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,KAAU,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;4BAE1I,IAAI,YAAY,EAAE;gCAChB,YAAY,CAAC,SAAS,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;gCAC3C,UAAU,CAAC,GAAG,EAAE;oCACd,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;gCAChD,CAAC,EAAE,IAAI,CAAC,CAAC;6BACV;yBACF;wBAED,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,CAAC;qBACnC;iBACF;aACF;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,EAAE;YACvB,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACzC,MAAM,GAAG,GAAQ,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,KAAU,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YAE7H,IAAI,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE;gBAC/B,IAAI;gBACJ,GAAG;aACJ,CAAC,EAAE;gBACF,IAAI,GAAG,EAAE;oBACP,GAAG,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;iBACrC;gBAED,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC;gBAEpB,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;oBAC1B,IAAI;oBACJ,GAAG;iBACJ,CAAC,CAAC;aACJ;SACF;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,KAAK;QACH,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC;IAC1B,CAAC;IAED;;OAEG;IACH,KAAK;QACH,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAC3C,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QAEpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,GAAG,CAAC,IAAI;QACN,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAExB,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;SACxP;aAAM;YACL,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;SAC5B;IACH,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,KAAK;QACX,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE;YACrB,KAAK,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;SACtB;QAED,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE;YAC1B,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAE/D,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,KAAK,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC,WAAW,EAAE,CAAC;QAChG,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,QAAQ,CAAC,KAAK;QACZ,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE;YACrB,KAAK,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;SACtB;QAED,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE;YAC1B,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAEhE,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,KAAK,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC,WAAW,EAAE,CAAC;QAChG,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,IAAI;QACV,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAExB,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;gBACnB,MAAM,CAAC,wBAAwB,CAAC,CAAC;aAClC;YAED,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SAC9E;aAAM;YACL,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;SAClC;IACH,CAAC;IAED;;OAEG;IACH,KAAK;QACH,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,KAAK;QACH,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,KAAK;QACV,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE;YAC1B,2CAA2C;YAC3C,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YAEvG,iEAAiE;YACjE,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,CAAC,EAAE;gBACxF,MAAM,CAAC,8CAA8C,CAAC,CAAC;aACxD;YACD,kEAAkE;YAClE,IAAI,IAAI,CAAC,YAAY,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,CAAC,EAAE;gBACvF,MAAM,CAAC,+CAA+C,CAAC,CAAC;aACzD;YAED,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBACnB,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;gBAE/B,OAAO,KAAK,IAAI,CAAC,EAAE;oBACjB,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;oBAE1B,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;iBAC5B;YACH,CAAC,CAAC,CAAC;SACJ;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,SAAS;QACP,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE;YAC1B,IAAI,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE;gBAC1C,IAAI,CAAC,cAAc,EAAE,CAAC;gBAEtB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,KAAU,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;gBAEhI,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;gBAEjB,IAAI,CAAC,oBAAoB,EAAE,CAAC;gBAE5B,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBAExB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;aACvC;SACF;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,aAAa,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;QACxC,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;YACvF,MAAM,GAAG,GAAQ,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,KAAU,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;YACpH,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAEhC,IAAI,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,EAAE;gBACpC,IAAI,cAAc,EAAE;oBAClB,IAAI,CAAC,cAAc,EAAE,CAAC;iBACvB;gBAED,IAAI,GAAG,EAAE;oBACP,GAAG,CAAC,MAAM,EAAE,CAAC;iBACd;gBAED,wCAAwC;gBACxC,+BAA+B;gBAC/B,IAAI,IAAI,CAAC,SAAS,EAAE;oBAClB,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,GAAG,KAAK,CAAC;iBAC9C;gBAED,IAAI,IAAI,CAAC,SAAS,IAAI,KAAK,EAAE;oBAC3B,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC;iBACrB;qBAAM,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,EAAE;oBAC9B,qCAAqC;oBACrC,IAAI,CAAC,SAAS,IAAI,CAAC,CAAC;iBACrB;gBAED,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;gBAE7B,IAAI,CAAC,oBAAoB,EAAE,CAAC;gBAE5B,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBAExB,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;aACjC;SACF;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK;QACV,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE;YAC3B,2CAA2C;YAC3C,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YAEvG,iEAAiE;YACjE,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,CAAC,EAAE;gBACxF,MAAM,CAAC,8CAA8C,CAAC,CAAC;aACxD;YACD,kEAAkE;YAClE,IAAI,IAAI,CAAC,YAAY,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM,CAAC,EAAE;gBACvF,MAAM,CAAC,+CAA+C,CAAC,CAAC;aACzD;YAED,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBACnB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;YACzC,CAAC,CAAC,CAAC;SACJ;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,aAAa,CAAC,KAAK;QACjB,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE;YAC3B,kBAAkB;YAClB,IAAI,CAAC,cAAc,EAAE,CAAC;YAEtB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE;gBAC7D,MAAM,GAAG,GAAQ,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,KAAU,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;gBACpH,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAEhC,IAAI,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;oBAC7B,IAAI;oBACJ,GAAG;iBACJ,CAAC,EAAE;oBACF,IAAI,GAAG,EAAE;wBACP,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;qBAClC;oBAED,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;oBAEvB,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE;wBACxB,IAAI;wBACJ,GAAG;qBACJ,CAAC,CAAC;iBACJ;aACF;SACF;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACH,IAAI,QAAQ;QACV,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,EAAE;YACvB,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;SACpC;aAAM;YACL,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IAED;;OAEG;IACH,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,IAAI,KAAK;QACP,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACnB,IAAI,IAAI,CAAC,YAAY,EAAE;gBACrB,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;aACzE;iBAAM;gBACL,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;aACjD;SACF;aAAM;YACL,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,MAAW,EAAE,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,MAAW,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;SACrH;IACH,CAAC;IAED;;OAEG;IACH,IAAI,KAAK,CAAC,MAAM;QACd,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACnB,CAAC;IAED;;;;OAIG;IACH,gBAAgB,CAAC,CAAC;QAChB,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,0DAA0D;YAC1D,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE;gBACrC,OAAO;aACR;YAED,6DAA6D;YAC7D,+CAA+C;YAC/C,IAAI,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,KAAK,QAAQ,EAAE;gBAC7D,OAAO;aACR;YAED,qCAAqC;YACrC,IAAI,CAAC,cAAc,EAAE,CAAC;SACvB;IACH,CAAC;IAED;;;;OAIG;IACH,oBAAoB,CAAC,CAAC;QACpB,CAAC,CAAC,cAAc,EAAE,CAAC;QAEnB,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,IAAI,CAAC,YAAY,EAAE;gBACrB,MAAM,IAAI,GAAG,EAAE,CAAC;gBAChB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC;gBAC3D,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC;gBAE7D,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;aAChB;iBAAM;gBACL,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;aACzC;YAED,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,EAAE,CAAC;YACvB,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YAEpB,IAAI,IAAI,CAAC,OAAO,CAAC,yBAAyB,EAAE;gBAC1C,IAAI,CAAC,cAAc,EAAE,CAAC;aACvB;SACF;IACH,CAAC;IAED;;;;OAIG;IACH,cAAc,CAAC,CAAC;QACd,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;IAED;;;;OAIG;IACH,aAAa,CAAC,CAAC;QACb,CAAC,CAAC,cAAc,EAAE,CAAC;QAEnB,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE;YAC3E,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,IAAI,CAAC,oBAAoB,EAAE,CAAC;SAC7B;IACH,CAAC;IAED;;;;OAIG;IACH,eAAe,CAAC,CAAC;QACf,CAAC,CAAC,cAAc,EAAE,CAAC;QAEnB,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,UAAU,CAAC,KAAK,IAAI,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE;YACxG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;YAEnB,OAAO,KAAK,CAAC;SACd;QAED,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACH,gBAAgB,CAAC,CAAC;QAChB,CAAC,CAAC,cAAc,EAAE,CAAC;QAEnB,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IAChD,CAAC;IAED;;;;OAIG;IACH,eAAe,CAAC,CAAC;QACf,MAAM,GAAG,GAAG,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,KAAK,CAAC;QAE/C,QAAQ,GAAG,EAAE;YACX,YAAY;YACZ,KAAK,CAAC;gBACJ,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE;oBAC1B,IAAI,IAAI,CAAC,aAAa,EAAE,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,EAAE;wBAC/C,MAAM,gBAAgB,GAAG,IAAI,CAAC,SAAS,CAAC;wBACxC,6EAA6E;wBAC7E,IAAI,gBAAgB,IAAI,CAAC,EAAE;4BACzB,IAAI,CAAC,aAAa,CAAC,gBAAgB,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAC,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAC;yBAC7G;wBAED,IAAI,CAAC,aAAa,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;qBAC7C;iBACF;gBAED,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE;oBAC3E,IAAI,CAAC,cAAc,EAAE,CAAC;iBACvB;gBACD,MAAM;YACR,SAAS;YACT,KAAK,EAAE;gBACL,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,EAAE;oBACvB,IAAI,CAAC,cAAc,EAAE,CAAC;iBACvB;gBAED,IAAI,CAAC,cAAc,EAAE,CAAC;gBACtB,MAAM;YACR,SAAS;YACT,KAAK,EAAE;gBACL,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE;oBAC1B,IAAI,IAAI,CAAC,aAAa,EAAE,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,EAAE;wBAC/C,MAAM,gBAAgB,GAAG,IAAI,CAAC,SAAS,CAAC;wBAExC,6EAA6E;wBAC7E,IAAI,gBAAgB,IAAI,CAAC,EAAE;4BACzB,IAAI,CAAC,aAAa,CAAC,gBAAgB,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAC,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAC;yBAC7G;wBAED,IAAI,CAAC,aAAa,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;qBAC7C;iBACF;gBAED,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE;oBAC3E,IAAI,CAAC,cAAc,EAAE,CAAC;iBACvB;gBACD,MAAM;YACR,aAAa;YACb,KAAK,EAAE;gBACL,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE;oBAC7B,IAAI,IAAI,CAAC,SAAS,GAAG,CAAC,EAAE;wBACtB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;qBAC5C;yBAAM;wBACL,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;qBAC3F;iBACF;gBACD,MAAM;YACR,cAAc;YACd,KAAK,EAAE;gBACL,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE;oBAC7B,IAAI,IAAI,CAAC,SAAS,GAAG,CAAC,EAAE;wBACtB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;qBACvB;yBAAM;wBACL,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC;qBACvF;iBACF;gBACD,MAAM;YACR;gBACE,IAAI,IAAI,CAAC,OAAO,CAAC,sBAAsB,EAAE;oBACvC,IAAI,CAAC,cAAc,EAAE,CAAC;iBACvB;YACH,SAAS;SACV;IACH,CAAC;IAED;;;;OAIG;IACH,gBAAgB,CAAC,CAAC;QAChB,MAAM,GAAG,GAAG,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,KAAK,CAAC;QAC/C,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QAErE,IAAI,CAAC,IAAI,CAAC,mBAAmB,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE;YAC1D,CAAC,CAAC,cAAc,EAAE,CAAC;YAEnB,OAAO,KAAK,CAAC;SACd;QAED,QAAQ;QACR,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,GAAG,KAAK,EAAE,EAAE;YAC/B,OAAO,KAAK,CAAC;SACd;QAED,IAAI,IAAI,CAAC,mBAAmB,EAAE;YAC5B,IAAI,CAAC,oBAAoB,CAAC,KAAY,CAAC,CAAC;SACzC;QAED,IAAI,IAAI,CAAC,mBAAmB,IAAI,IAAI,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,cAAc,IAAI,GAAG,KAAK,EAAE,EAAE;YACxG,IAAI,CAAC,aAAa,EAAE,CAAC;YACrB,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;YAC1C,IAAI,CAAC,cAAc,EAAE,CAAC;YAEtB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;gBAChC,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,OAAO,CAAC,CAAC;gBAEpD,IAAI,OAAO,CAAC,MAAM,EAAE;oBAClB,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;wBACvB,MAAM,IAAI,GAAG;4BACX,KAAK,EAAE,IAAI;4BACX,IAAI,EAAE,IAAI;yBACX,CAAC;wBAEF,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;4BACrB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC;4BACpB,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC;yBACpB;6BAAM;4BACL,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;4BAC5C,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;yBAC3C;wBAED,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;oBACjC,CAAC,CAAC,CAAC;iBACJ;gBAED,IAAI,CAAC,oBAAoB,CAAC,KAAY,CAAC,CAAC;gBAExC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YAC/C,CAAC,CAAC,CAAC;SACJ;QAED,IAAI,IAAI,CAAC,mBAAmB,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,GAAG,IAAI,EAAE,CAAC,EAAE;YACrF,2DAA2D;YAC3D,CAAC,CAAC,cAAc,EAAE,CAAC;YAEnB,iEAAiE;YACjE,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YACnD,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBACrB,gDAAgD;gBAChD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE;oBAC7D,qCAAqC;oBACrC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;iBACjB;YACH,CAAC,CAAC,CAAC;YAEH,KAAK,GAAG,EAAE,CAAC;YACX,cAAc;YACd,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,EAAE,CAAC;YAEvB,IAAI,CAAC,cAAc,EAAE,CAAC;YAEtB,OAAO,KAAK,CAAC;SACd;IACH,CAAC;IAED;;;;;;;;OAQG;IACH,sBAAsB,CAAC,CAAC;QACtB,IAAI,CAAC,CAAC,CAAC,MAAM,IAAI,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE;YACzE,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,aAAa,CAAC,KAAK,CAAC;SACpC;IACH,CAAC;IAED;;;;OAIG;IACH,WAAW,CAAC,CAAC;QACX,CAAC,CAAC,cAAc,EAAE,CAAC;QAEnB,IAAI,CAAC,CAAC,aAAa,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;YAChD,OAAO,KAAK,CAAC;SACd;QAED,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,UAAU,CAAC,KAAK,IAAI,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE;YACxG,OAAO,KAAK,CAAC;SACd;QAED,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QAEpB,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE;YAC3B,MAAM,GAAG,GAAG,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAE5C,IAAI,GAAG,EAAE;gBACP,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;gBAClE,IAAI,QAAQ,KAAK,IAAI,CAAC,SAAS,EAAE;oBAC/B,IAAI,CAAC,cAAc,EAAE,CAAC;iBACvB;qBAAM;oBACL,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;iBAC9B;aACF;SACF;IACH,CAAC;IAED;;;;OAIG;IACH,iBAAiB,CAAC,CAAC;QACjB,CAAC,CAAC,cAAc,EAAE,CAAC;QAEnB,IAAI,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,UAAU,CAAC,KAAK,IAAI,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE;YACxG,OAAO,KAAK,CAAC;SACd;QAED,MAAM,GAAG,GAAG,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAE5C,IAAI,GAAG,EAAE;YACP,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;SACtE;IACH,CAAC;CACF","sourcesContent":["/* eslint-disable */\nimport Component from './utils/component';\nimport { cloneAttributes } from './utils/dom';\nimport { isString, BooleanParse, isObject, isPromise, isFunction } from './utils/type';\nimport defaultOptions from './defaultOptions';\nimport tagTemplate from './templates/tag';\nimport containerTemplate from './templates/wrapper';\nimport dropdownItemTemplate from './templates/dropdown-item';\n\n// TODO: add pattern or function to valdiate value before adding\n\nexport default class BulmaTagsInput extends Component {\n  private _items: any[];\n  private _selected;\n  private _isSelect;\n  private _isMultiple;\n  private _objectItems;\n  private _input;\n  private _manualInputAllowed;\n  private _filterInputAllowed;\n  private source;\n  private container;\n  private dropdown;\n  private dropdownEmptyOption;\n\n  constructor(element, options = {}) {\n    super(element, options, defaultOptions);\n\n    // Convert Boolean string options to full Boolean\n    this.options.allowDuplicates = BooleanParse(this.options.allowDuplicates);\n    this.options.caseSensitive = BooleanParse(this.options.caseSensitive);\n    this.options.clearSelectionOnTyping = BooleanParse(this.options.clearSelectionOnTyping);\n    this.options.closeDropdownOnItemSelect = BooleanParse(this.options.closeDropdownOnItemSelect);\n    this.options.freeInput = BooleanParse(this.options.freeInput);\n    this.options.highlightDuplicate = BooleanParse(this.options.highlightDuplicate);\n    this.options.highlightMatchesString = BooleanParse(this.options.highlightMatchesString);\n    this.options.removable = BooleanParse(this.options.removable);\n    this.options.searchOn = this.options.searchOn.toLowerCase();\n    this.options.selectable = BooleanParse(this.options.selectable);\n    this.options.trim = BooleanParse(this.options.trim);\n\n    //Bind events to current class\n    this._onDocumentClick = this._onDocumentClick.bind(this);\n    this._onInputChange = this._onInputChange.bind(this);\n    this._onInputClick = this._onInputClick.bind(this);\n    this._onInputFocusOut = this._onInputFocusOut.bind(this);\n    this._onInputFocusIn = this._onInputFocusIn.bind(this);\n    this._onInputKeyDown = this._onInputKeyDown.bind(this);\n    this._onInputKeyPress = this._onInputKeyPress.bind(this);\n    this._onOriginalInputChange = this._onOriginalInputChange.bind(this);\n    this._onTagDeleteClick = this._onTagDeleteClick.bind(this);\n    this._onTagClick = this._onTagClick.bind(this);\n    this._onDropdownItemClick = this._onDropdownItemClick.bind(this);\n\n    // Define internal variables\n    this._items = [];\n    this._selected = -1; // index of selected item\n\n    // Initiate plugin\n    this._init();\n  }\n\n  /**\n   * Initiate all DOM element corresponding to selector\n   *\n   * @method\n   * @return Array of all Plugin instances\n   */\n  static attach(selector = 'input[data-type=\"tags\"], input[type=\"tags\"], select[data-type=\"tags\"], select[type=\"tags\"]', options = {}, container = null) {\n    return super.attach(selector, options, container);\n  }\n\n  /**\n   * Initiate plugin\n   *\n   * @method init\n   * @return\n   */\n  _init() {\n    // Detect if original input was a Select element\n    this._isSelect = (this.element.tagName === 'SELECT');\n    this._isMultiple = (this._isSelect && this.element.hasAttribute('multiple'));\n\n    // Detect if we work with Object items or not\n    // Object Items is forced when working with select element\n    this._objectItems = (typeof this.options.itemValue !== 'undefined') || this._isSelect;\n    this.options.itemValue = this.options.itemValue ? this.options.itemValue : (this._isSelect ? 'value' : undefined);\n    this.options.itemText = this.options.itemText ? this.options.itemText : (this._isSelect ? 'text' : undefined);\n    // If no itemText pass then use itemValue as itemText\n    if (typeof this.options.itemText === 'undefined') {\n      this.options.itemText = this.options.itemValue;\n    }\n\n    // Force freeInput to False if working with object items\n    this.options.freeInput = this._objectItems ? false : this.options.freeInput;\n\n    // Init search engine\n    this.source = null;\n    if (typeof this.options.source !== 'undefined') {\n      // Fix searchOn option if wrong\n      if (!['value', 'text'].includes(this.options.searchOn)) {\n        this.options.searchOn = defaultOptions.searchOn;\n      }\n\n      if (isPromise(this.options.source)) {\n        this.source = this.options.source;\n      } else if (isFunction(this.options.source)) {\n        this.source = value => Promise.resolve(this.options.source(value));\n      } else if (Array.isArray(this.options.source)) {\n        this.source = value => Promise.resolve(this.options.source.filter(i => {\n          const val = (this._objectItems ? i[this.options.itemValue] : i);\n\n          return this.options.caseSensitive ? val.includes(value) : val.toLowerCase().includes(value.toLowerCase());\n        }));\n      }\n    }\n\n    // Determine allowed input modes\n    this._manualInputAllowed = !this._isSelect && this.options.freeInput;\n    this._filterInputAllowed = this._isSelect || this.source;\n\n    this._build();\n  }\n\n  /**\n   * Build TagsInput DOM elements\n   */\n  _build() {\n    // Create TagsInput DOM\n    const containerFragment = document.createRange().createContextualFragment(containerTemplate({\n      emptyTitle: typeof this.options.noResultsLabel !== 'undefined' ? this.options.noResultsLabel : 'No results found',\n      placeholder: this.element.placeholder ? this.element.placeholder : this.options.placeholder,\n      uuid: this.id\n    }));\n\n    this.container = containerFragment.firstElementChild;\n    this._input = this.container.querySelector('input');\n    this.dropdown = this.container.querySelector(`#${this.id}-list .dropdown-content`);\n    this.dropdownEmptyOption = this.dropdown.querySelector('.empty-title');\n\n    // Clone attributes between original and new input\n    cloneAttributes(this._input, this.element, 'data-type multiple name type value');\n\n    if (this.element.disabled) {\n      this.container.setAttribute('disabled', 'disabled');\n      this.options.removable = false;\n      this.options.selectable = false;\n    }\n\n    // Propagate original input disabled attribute to the container\n    if (this._input.getAttribute('disabled') || this._input.classList.contains('is-disabled')) {\n      this.container.setAttribute('disabled', 'disabled');\n    }\n\n    if (!this._manualInputAllowed) {\n      this.container.classList.add(this._filterInputAllowed ? 'is-filter' : 'no-input');\n    }\n\n    // Remove dropdown if no source or original input is not a select element\n    if (!this._isSelect && typeof this.options.source === 'undefined') {\n      this.dropdown.remove();\n      this.dropdown = null;\n      this._input.setAttribute('list', null);\n    }\n\n    // Initialize plugin value from original input value\n    if (this._isSelect) {\n      Array.from(this.element.options).forEach((option: any) => {\n        if (option.selected) {\n          // HTML Option element contains value and text properties\n          // Add it silently to not propagate to the original element\n          this.add(option.value ? option : {\n            value: option.text,\n            text: option.text\n          }, true);\n        }\n\n        this._createDropdownItem(option);\n      });\n    } else {\n      // We have on input element\n      if (this.element.value.length) {\n        this.add(this._objectItems ? JSON.parse(this.element.value) : this.element.value, true);\n      }\n    }\n\n    this._bindEvents();\n\n    // Insert container right before original input and make original input hidden\n    this.element.parentNode.insertBefore(this.container, this.element);\n\n    // Hide original input (type=\"hidden\" only works on select)\n    this.element.style.display = 'none';\n  }\n\n  /**\n   * Bind all events listener\n   */\n  _bindEvents() {\n    // Bind document click event to close dropdown\n    document.addEventListener('click', this._onDocumentClick);\n\n    // Bind event handlers to orginal input\n    this.element.addEventListener('change', this._onOriginalInputChange);\n\n    // Bind event handlers to internal input\n    this._input.addEventListener('input', this._onInputChange);\n    this._input.addEventListener('click', this._onInputClick);\n    this._input.addEventListener('keydown', this._onInputKeyDown);\n    this._input.addEventListener('keypress', this._onInputKeyPress);\n    this._input.addEventListener('focusout', this._onInputFocusOut);\n    this._input.addEventListener('focusin', this._onInputFocusIn);\n  }\n\n  /**\n   * Check if caret is at the beginning of the input value\n   */\n  _caretAtStart() {\n    try {\n      return this._input.selectionStart === 0 && this._input.selectionEnd === 0;\n    } catch (e) {\n      return this._input.value === '';\n    }\n  }\n\n  /**\n   * Check value length constraint if option activated\n   *\n   * @param item\n   */\n  _checkLength(item) {\n    const value = this._objectItems ? item[this.options.itemValue] : item;\n\n    if (!isString(value)) {\n      return true;\n    }\n\n    return value.length >= this.options.minChars && (typeof this.options.maxChars === 'undefined' || value.length <= this.options.maxChars);\n  }\n\n  /**\n   * Close dropdown\n   */\n  _closeDropdown() {\n    if (this.dropdown) {\n      this.emit('before.dropdown.close', this);\n\n      this.container.classList.remove('is-active');\n\n      this.emit('after.dropdown.close', this);\n    }\n  }\n\n  /**\n   * Create a new dropdown item based on given item data\n   *\n   * @param item\n   */\n  _createDropdownItem(item) {\n    if (this.dropdown) {\n      // TODO: add possibility to provide template through options\n      const dropdownItemFragment = document.createRange().createContextualFragment(dropdownItemTemplate({\n        text: item.text,\n        value: item.value\n      }));\n      const dropdownItem = dropdownItemFragment.firstElementChild;\n\n      // Save item data into dataset\n      (dropdownItem as any).dataset.value = item.value;\n      (dropdownItem as any).dataset.text = item.text;\n\n      dropdownItem!.addEventListener('click', this._onDropdownItemClick);\n\n      this.dropdown.append(dropdownItem);\n    }\n  }\n\n  /**\n   * Create a new tag and add it to the DOM\n   *\n   * @param string value\n   */\n  _createTag(item) {\n    const tagFragment = document.createRange().createContextualFragment(tagTemplate({\n      removable: this.options.removable,\n      style: this.options.tagClass,\n      text: item.text,\n      value: item.value\n    }));\n    const tag = tagFragment.firstElementChild;\n\n    // Attach tag click event to select it\n    tag!.addEventListener('click', this._onTagClick);\n\n    if (this.options.removable) {\n      // Find delete button and attach click event\n      const deleteButton = tag!.querySelector('.delete');\n      if (deleteButton) {\n        deleteButton.addEventListener('click', this._onTagDeleteClick);\n      }\n    }\n\n    // insert new tag at the end (ie just before input)\n    this.container.insertBefore(tag, this._input);\n  }\n\n  /**\n   * Remove all dropdown items except the empty title\n   */\n  _emptyDropdown() {\n    if (this.dropdown) {\n      Array.from(this.dropdown.children).filter((child: any) => !child.classList.contains('empty-title')).forEach((child: any) => {\n        child.remove();\n      });\n    }\n  }\n\n  /**\n   * Find needle into a string and wrap it with <mark> HTML tag\n   *\n   * @param string\n   * @param needle\n   */\n  _highlightMatchesInString(string, needle) {\n    const reg = '(' + needle + ')(?![^<]*>|[^<>]*</)'; // explanation: http://stackoverflow.com/a/18622606/1147859\n    const regex = new RegExp(reg, 'i');\n\n    // If the regex doesn't match the string just return initial string\n    if (!string.match(regex)) {\n      return string;\n    }\n\n    // Otherwise, get to highlighting\n    const matchStartPosition = string.match(regex).index;\n    const matchEndPosition = matchStartPosition + string.match(regex)[0].toString().length;\n    const originalTextFoundByRegex = string.substring(matchStartPosition, matchEndPosition);\n    string = string.replace(regex, `<mark class=\"is-highlighted\">${originalTextFoundByRegex}</mark>`);\n\n    return string;\n  }\n\n  /**\n   * Open dropdown\n   */\n  _openDropdown() {\n    if (this.dropdown) {\n      this.container.classList.add('is-active');\n    }\n  }\n\n  /**\n   * Propagate internal input changes to the original input\n   */\n  _propagateChange() {\n    if (!this._isSelect) {\n      // If original element is an input element\n      this.element.value = this.value;\n    } else {\n      // If original element is a select element\n      Array.from(this.element.options).forEach((option: any) => {\n        option.setAttribute('selected', undefined);\n        option.selected = false;\n\n        // If option has been added by TagsInput then we remove it\n        // Otherwise it is an original option\n        if (typeof option.dataset.source !== 'undefined') {\n          option.remove();\n        }\n      });\n\n      // Update original element options selected attributes\n      this._items.forEach(item => {\n        this._updateSelectOptions({\n          value: this._objectItems ? item[this.options.itemValue] : item,\n          text: this._objectItems ? item[this.options.itemText] : item\n        });\n      });\n    }\n\n    // Trigger Change event manually (because original input is now hidden)\n    // Trick: Passes current class constructor name to prevent loop with _onOriginalInputChange handler)\n    const changeEvent = new CustomEvent('change', {\n      detail: this.constructor.name\n    });\n    this.element.dispatchEvent(changeEvent);\n  }\n\n  /**\n   * Trim value if option activated\n   *\n   * @param item\n   */\n  _trim(item) {\n    if (this.options.trim) {\n      if (this._objectItems) {\n        if (isString(item[this.options.itemValue])) {\n          item[this.options.itemValue] = item[this.options.itemValue].trim();\n        }\n\n        if (isString(item[this.options.itemText])) {\n          item[this.options.itemText] = item[this.options.itemText].trim();\n        }\n      } else {\n        item = item.trim();\n      }\n    }\n\n    return item;\n  }\n\n  /**\n   * Filter Dropdown items to be compliant with already selected items and current input value\n   * Filtering is made on Text by default (can be changed with option)\n   */\n  _filterDropdownItems(value: any = null) {\n    if (this.dropdown) {\n      if (this.emit('before.dropdown.filter', this)) {\n        Array.from(this.dropdown.children).filter((child: any) => !child.classList.contains('empty-title')).forEach((child: any) => {\n          const childValue = child.dataset[this.options.searchOn];\n\n          // Remove highlights\n          if (this.options.highlightMatchesString) {\n            child.textContent = child.textContent.replace(/<\\/?(mark\\s?(class=\"is\\-highlighted\")?)?>]*>?/gm, '');\n          }\n\n          // If value is found in dropdown\n          if ((value && value.length)) {\n            if (this.options.caseSensitive) {\n              child.style.display = childValue.includes(value) ? 'block' : 'none';\n            } else {\n              child.style.display = childValue.toLowerCase().includes(value.toLowerCase()) ? 'block' : 'none';\n            }\n\n            if (this.options.highlightMatchesString) {\n              child.innerHTML = this._highlightMatchesInString(child.innerHTML, value);\n            }\n          } else {\n            child.style.display = 'block';\n          }\n\n          if (!this.options.allowDuplicates || (this._isSelect && !this._isMultiple)) {\n            const hasValue = this.options.searchOn === 'value' ? this.hasValue(childValue) : this.hasText(childValue);\n\n            child.style.display = hasValue ? 'none' : child.style.display;\n          }\n        });\n\n        const hasActiveItems = Array.from(this.dropdown.children).filter((child: any) => !child.classList.contains('empty-title')).some((child: any) => child.style.display !== 'none');\n        if (hasActiveItems) {\n          this.dropdownEmptyOption.style.display = 'none';\n        } else {\n          this.dropdownEmptyOption.style.display = 'block';\n        }\n\n        this.emit('after.dropdown.filter', this);\n\n        return hasActiveItems;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Update original select option based on given item\n   *\n   * @param item\n   */\n  _updateSelectOptions(item) {\n    if (this._isSelect) {\n      // Check to see if the tag exists in its raw or uri-encoded form\n      let option = this.element.querySelector(`option[value=\"${encodeURIComponent(item.value)}\"]`) || this.element.querySelector(`option[value=\"${item.value}\"]`);\n\n      // add <option /> if item represents a value not present in one of the <select />'s options\n      if (!option) {\n        const optionFragment = document.createRange().createContextualFragment(`<option value=\"${item.value}\" data-source=\"${this.id}\" selected>${item.text}</option>`);\n        option = optionFragment.firstElementChild;\n\n        this.element.add(option);\n      }\n\n      // mark option as selected\n      option.setAttribute('selected', 'selected');\n      option.selected = true;\n    }\n  }\n\n  /**\n   * Add given item\n   * item = 'john'\n   * item = 'john,jane'\n   * item = ['john', 'jane']\n   * item = [{\n   *  \"value\": \"1\",\n   *  \"text\": \"John\"\n   * }, {\n   *  \"value\": \"2\",\n   *  \"text\": \"Jane\"\n   * }]\n   *\n   * @param item\n   * @param silently Should the change be propagated to the original element\n   */\n  add(items, silently = false) {\n    // Check if number of items is limited ans reached\n    if (typeof this.options.maxTags !== 'undefined' && this._items.length >= this.options.maxTags) {\n      return this;\n    }\n\n    // Make sure to work with an array of items\n    items = Array.isArray(items) ? items : isObject(items) ? [items] : items.split(this.options.delimiter);\n\n    // If string items are expected then check every item is a string\n    if (!this._objectItems && (items.filter(item => isString(item)).length !== items.length)) {\n      throw ('Item must be a string or an array of strings');\n    }\n\n    // If object items are expected then check every item is an object\n    if (this._objectItems && (items.filter(item => isObject(item)).length !== items.length)) {\n      throw ('Item must be an object or an array of objects');\n    }\n\n    items.forEach(item => {\n      item = this._trim(item);\n\n      // Check if item respects min/max chars\n      if (this._checkLength(item)) {\n\n        // If original input is a non multiple select element\n        if (this._isSelect && !this._isMultiple && this._items.length > 0) {\n          this.removeAtIndex(0);\n          this.element.remove(this.element.selectedIndex);\n        }\n\n        // check if duplicates are allowed or not\n        if (item = this.emit('before.add', item)) {\n          if (this.options.allowDuplicates || !this.has(item)) {\n            const itemData = {\n              value: this._objectItems ? item[this.options.itemValue] : item,\n              text: this._objectItems ? item[this.options.itemText] : item\n            };\n\n            const tag = this._createTag(itemData);\n\n            // save item into the internal array\n            this._items.push(item);\n\n            if (!silently) {\n              // Propagate change event to the original input\n              this._propagateChange();\n\n              this.emit('after.add', {\n                item,\n                tag\n              });\n            }\n          } else {\n            if (this.options.highlightDuplicate) {\n              const duplicateTag: any = Array.from(this.container.children).filter((child: any) => child.classList.contains('tag'))[this.indexOf(item)];\n\n              if (duplicateTag) {\n                duplicateTag.classList.add('is-duplicate');\n                setTimeout(() => {\n                  duplicateTag.classList.remove('is-duplicate');\n                }, 1250);\n              }\n            }\n\n            this.emit('item.duplicate', item);\n          }\n        }\n      }\n    });\n\n    return this;\n  }\n\n  /**\n   * Unselect the selected item\n   */\n  clearSelection() {\n    if (this._selected >= 0) {\n      const item = this._items[this._selected];\n      const tag: any = Array.from(this.container.children).filter((child: any) => child.classList.contains('tag'))[this._selected];\n\n      if (this.emit('before.unselect', {\n        item,\n        tag\n      })) {\n        if (tag) {\n          tag.classList.remove('is-selected');\n        }\n\n        this._selected = -1;\n\n        this.emit('after.unselect', {\n          item,\n          tag\n        });\n      }\n    }\n\n    return this;\n  }\n\n  /**\n   * Shortcut to removeAll method\n   */\n  flush() {\n    return this.removeAll();\n  }\n\n  /**\n   * Sets focus on the input\n   */\n  focus() {\n    this.container.classList.add('is-focused');\n    this._input.focus();\n\n    return this;\n  }\n\n  /**\n   * Check if given item is present\n   *\n   * @param item\n   */\n  has(item) {\n    item = this._trim(item);\n\n    if (this._objectItems) {\n      return this._items.some(i => this.options.caseSensitive || !isString(i[this.options.itemValue]) ? i[this.options.itemValue] === item[this.options.itemValue] : i[this.options.itemValue].toLowerCase() === item[this.options.itemValue].toLowerCase());\n    } else {\n      return this.hasValue(item);\n    }\n  }\n\n  /**\n   * Check if given text is present\n   *\n   * @param value\n   */\n  hasText(value) {\n    if (this.options.trim) {\n      value = value.trim();\n    }\n\n    return this._items.some(i => {\n      const val = (this._objectItems ? i[this.options.itemText] : i);\n\n      return this.options.caseSensitive ? val === value : val.toLowerCase() === value.toLowerCase();\n    });\n  }\n\n  /**\n   * Check if given value is present\n   *\n   * @param value\n   */\n  hasValue(value) {\n    if (this.options.trim) {\n      value = value.trim();\n    }\n\n    return this._items.some(i => {\n      const val = (this._objectItems ? i[this.options.itemValue] : i);\n\n      return this.options.caseSensitive ? val === value : val.toLowerCase() === value.toLowerCase();\n    });\n  }\n\n  /**\n   * Get index of given item\n   *\n   * @param item\n   */\n  indexOf(item) {\n    item = this._trim(item);\n\n    if (this._objectItems) {\n      if (!isObject(item)) {\n        throw ('Item must be an object');\n      }\n\n      return this._items.map(function (e) { return e.value; }).indexOf(item.value);\n    } else {\n      return this._items.indexOf(item);\n    }\n  }\n\n  /**\n   * Returns the internal input element\n   */\n  input() {\n    return this._input;\n  }\n\n  /**\n   * Get items\n   */\n  items() {\n    return this._items;\n  }\n\n  /**\n   * Remove given item\n   * item = 'john'\n   * item = 'john,jane'\n   *\n   * @param String item\n   */\n  remove(items) {\n    if (this.options.removable) {\n      // Make sure to work with an array of items\n      items = Array.isArray(items) ? items : isObject(items) ? [items] : items.split(this.options.delimiter);\n\n      // If string items are expected then check every item is a string\n      if (!this._objectItems && (items.filter(item => isString(item)).length !== items.length)) {\n        throw ('Item must be a string or an array of strings');\n      }\n      // If object items are expected then check every item is an object\n      if (this._objectItems && (items.filter(item => isObject(item)).length !== items.length)) {\n        throw ('Item must be an object or an array of objects');\n      }\n\n      items.forEach(item => {\n        let index = this.indexOf(item);\n\n        while (index >= 0) {\n          this.removeAtIndex(index);\n\n          index = this.indexOf(item);\n        }\n      });\n    }\n\n    return this;\n  }\n\n  /**\n   * Remove all tags at once\n   */\n  removeAll() {\n    if (this.options.removable) {\n      if (this.emit('before.flush', this._items)) {\n        this.clearSelection();\n\n        Array.from(this.container.children).filter((child: any) => child.classList.contains('tag')).forEach((tag: any) => tag.remove());\n\n        this._items = [];\n\n        this._filterDropdownItems();\n\n        this._propagateChange();\n\n        this.emit('after.flush', this._items);\n      }\n    }\n\n    return this;\n  }\n\n  /**\n   * Remove item at given index\n   *\n   * @param Integer index\n   */\n  removeAtIndex(index, clearSelection = true) {\n    if (this.options.removable && !isNaN(index) && index >= 0 && index < this._items.length) {\n      const tag: any = Array.from(this.container.children).filter((child: any) => child.classList.contains('tag'))[index];\n      const item = this._items[index];\n\n      if (this.emit('before.remove', item)) {\n        if (clearSelection) {\n          this.clearSelection();\n        }\n\n        if (tag) {\n          tag.remove();\n        }\n\n        // If original input is a select element\n        // then deselect related option\n        if (this._isSelect) {\n          this.element.options[index].selected = false;\n        }\n\n        if (this._selected == index) {\n          this._selected = -1;\n        } else if (this._selected >= 0) {\n          // One item less so selected index is\n          this._selected -= 1;\n        }\n\n        this._items.splice(index, 1);\n\n        this._filterDropdownItems();\n\n        this._propagateChange();\n\n        this.emit('after.remove', item);\n      }\n    }\n\n    return this;\n  }\n\n  /**\n   * Select given item\n   *\n   * @param item\n   */\n  select(items) {\n    if (this.options.selectable) {\n      // Make sure to work with an array of items\n      items = Array.isArray(items) ? items : isObject(items) ? [items] : items.split(this.options.delimiter);\n\n      // If string items are expected then check every item is a string\n      if (!this._objectItems && (items.filter(item => isString(item)).length !== items.length)) {\n        throw ('Item must be a string or an array of strings');\n      }\n      // If object items are expected then check every item is an object\n      if (this._objectItems && (items.filter(item => isObject(item)).length !== items.length)) {\n        throw ('Item must be an object or an array of objects');\n      }\n\n      items.forEach(item => {\n        this.selectAtIndex(this.indexOf(item));\n      });\n    }\n\n    return this;\n  }\n\n  /**\n   * Select tag at given index\n   *\n   * @param Integer index\n   */\n  selectAtIndex(index) {\n    if (this.options.selectable) {\n      // Clear selection\n      this.clearSelection();\n\n      if (!isNaN(index) && index >= 0 && index < this._items.length) {\n        const tag: any = Array.from(this.container.children).filter((child: any) => child.classList.contains('tag'))[index];\n        const item = this._items[index];\n\n        if (this.emit('before.select', {\n          item,\n          tag\n        })) {\n          if (tag) {\n            tag.classList.add('is-selected');\n          }\n\n          this._selected = index;\n\n          this.emit('after.select', {\n            item,\n            tag\n          });\n        }\n      }\n    }\n\n    return this;\n  }\n\n  /**\n   * Get selected item\n   */\n  get selected() {\n    if (this._selected >= 0) {\n      return this._items[this._selected];\n    } else {\n      return null;\n    }\n  }\n\n  /**\n   * Get selected item index\n   */\n  get selectedIndex() {\n    return this._selected;\n  }\n\n  /**\n   * Get value\n   */\n  get value() {\n    if (!this._isSelect) {\n      if (this._objectItems) {\n        return this._items.map(item => item.value).join(this.options.delimiter);\n      } else {\n        return this._items.join(this.options.delimiter);\n      }\n    } else {\n      return Array.from(this.element.options).filter((option: any) => option.selected).map((option: any) => option.value);\n    }\n  }\n\n  /**\n   * Set value\n   */\n  set value(string) {\n    this.removeAll();\n    this.add(string);\n  }\n\n  /**\n   * Document click event handler\n   *\n   * @param e\n   */\n  _onDocumentClick(e) {\n    if (this.dropdown) {\n      // If we click on element inside container then do nothing\n      if (this.container.contains(e.target)) {\n        return;\n      }\n\n      // Tag and delete button already deleted when event triggered\n      // So we check if target is a tag delete button\n      if (e.target.dataset.tag && e.target.dataset.tag === 'delete') {\n        return;\n      }\n\n      // Click outside dropdown so close it\n      this._closeDropdown();\n    }\n  }\n\n  /**\n   * Input focus lost event handler\n   *\n   * @param e\n   */\n  _onDropdownItemClick(e) {\n    e.preventDefault();\n\n    if (this.dropdown) {\n      if (this._objectItems) {\n        const item = {};\n        item[this.options.itemText] = e.currentTarget.dataset.text;\n        item[this.options.itemValue] = e.currentTarget.dataset.value;\n\n        this.add(item);\n      } else {\n        this.add(e.currentTarget.dataset.value);\n      }\n\n      this._filterDropdownItems();\n      this._input.value = '';\n      this._input.focus();\n\n      if (this.options.closeDropdownOnItemSelect) {\n        this._closeDropdown();\n      }\n    }\n  }\n\n  /**\n   * Input change event handler\n   *\n   * @param e\n   */\n  _onInputChange(e) {\n    this._filterDropdownItems(this._input.value);\n  }\n\n  /**\n   * Input click event handler\n   *\n   * @param e\n   */\n  _onInputClick(e) {\n    e.preventDefault();\n\n    if (!this.source || this._input.value.length >= this.options.searchMinChars) {\n      this._openDropdown();\n      this._filterDropdownItems();\n    }\n  }\n\n  /**\n   * Input focus event handler\n   *\n   * @param e\n   */\n  _onInputFocusIn(e) {\n    e.preventDefault();\n\n    if (this.container.getAttribute('disabled') !== null || this.container.classList.contains('is-disabled')) {\n      this._input.blur();\n\n      return false;\n    }\n\n    this.container.classList.add('is-focused');\n  }\n\n  /**\n   * Input focus lost event handler\n   *\n   * @param e\n   */\n  _onInputFocusOut(e) {\n    e.preventDefault();\n\n    this.container.classList.remove('is-focused');\n  }\n\n  /**\n   * Input Keydown event handler\n   *\n   * @param e\n   */\n  _onInputKeyDown(e) {\n    const key = e.charCode || e.keyCode || e.which;\n\n    switch (key) {\n      // BACKSPACE\n      case 8:\n        if (this.options.removable) {\n          if (this._caretAtStart() && this._selected >= 0) {\n            const currentItemIndex = this._selected;\n            // If tag was selected then select next (or previous if next does not exists)\n            if (currentItemIndex >= 0) {\n              this.selectAtIndex(currentItemIndex + 1 < this._items.length ? currentItemIndex + 1 : currentItemIndex - 1);\n            }\n\n            this.removeAtIndex(currentItemIndex, false);\n          }\n        }\n\n        if (this.source && (this._input.value.length) < this.options.searchMinChars) {\n          this._closeDropdown();\n        }\n        break;\n      // ESCAPE\n      case 27:\n        if (this._selected >= 0) {\n          this.clearSelection();\n        }\n\n        this._closeDropdown();\n        break;\n      // DELETE\n      case 46:\n        if (this.options.removable) {\n          if (this._caretAtStart() && this._selected >= 0) {\n            const currentItemIndex = this._selected;\n\n            // If tag was selected then select next (or previous if next does not exists)\n            if (currentItemIndex >= 0) {\n              this.selectAtIndex(currentItemIndex + 1 < this._items.length ? currentItemIndex + 1 : currentItemIndex - 1);\n            }\n\n            this.removeAtIndex(currentItemIndex, false);\n          }\n        }\n\n        if (this.source && (this._input.value.length) < this.options.searchMinChars) {\n          this._closeDropdown();\n        }\n        break;\n      // LEFT ARROW\n      case 37:\n        if (!this._input.value.length) {\n          if (this._selected < 0) {\n            this.selectAtIndex(this._items.length - 1);\n          } else {\n            this.selectAtIndex(this._selected - 1 >= 0 ? this._selected - 1 : this._items.length - 1);\n          }\n        }\n        break;\n      // RIGHT ARROW\n      case 39:\n        if (!this._input.value.length) {\n          if (this._selected < 0) {\n            this.selectAtIndex(0);\n          } else {\n            this.selectAtIndex(this._selected + 1 >= this._items.length ? 0 : this._selected + 1);\n          }\n        }\n        break;\n      default:\n        if (this.options.clearSelectionOnTyping) {\n          this.clearSelection();\n        }\n      // ignore\n    }\n  }\n\n  /**\n   * Input Keypress event handler\n   *\n   * @param e\n   */\n  _onInputKeyPress(e) {\n    const key = e.charCode || e.keyCode || e.which;\n    let value = this._trim(this._input.value) + String.fromCharCode(key);\n\n    if (!this._manualInputAllowed && !this._filterInputAllowed) {\n      e.preventDefault();\n\n      return false;\n    }\n\n    // ENTER\n    if (!value.length && key !== 13) {\n      return false;\n    }\n\n    if (this._filterInputAllowed) {\n      this._filterDropdownItems(value as any);\n    }\n\n    if (this._filterInputAllowed && this.source && value.length >= this.options.searchMinChars && key !== 13) {\n      this._openDropdown();\n      this.dropdown.classList.add('is-loading');\n      this._emptyDropdown();\n\n      this.source(value).then(results => {\n        results = this.emit('on.results.received', results);\n\n        if (results.length) {\n          results.forEach(result => {\n            const item = {\n              value: null,\n              text: null\n            };\n\n            if (!isObject(result)) {\n              item.value = result;\n              item.text = result;\n            } else {\n              item.value = result[this.options.itemValue];\n              item.text = result[this.options.itemText];\n            }\n\n            this._createDropdownItem(item);\n          });\n        }\n\n        this._filterDropdownItems(value as any);\n\n        this.dropdown.classList.remove('is-loading');\n      });\n    }\n\n    if (this._manualInputAllowed && (value.includes(this.options.delimiter) || key == 13)) {\n      // Prevent default behavior (ie: add char into input value)\n      e.preventDefault();\n\n      // Split value by delimiter in case we copy/paste multiple values\n      const values = value.split(this.options.delimiter);\n      values.forEach(value => {\n        // check if empty text when delimiter is removed\n        if ((value = value.replace(this.options.delimiter, '')) != '') {\n          // push to array and remove delimiter\n          this.add(value);\n        }\n      });\n\n      value = '';\n      // clear input\n      this._input.value = '';\n\n      this._closeDropdown();\n\n      return false;\n    }\n  }\n\n  /**\n   * Original input change event handler\n   * CAUTION: because original input is now hidden the change event must be triggered manually on change\n   * Example how to trigger change event manually\n   * var changeEvent = new Event('change');\n   * input.dispatchEvent(changeEvent);\n   *\n   * @param e\n   */\n  _onOriginalInputChange(e) {\n    if (!e.detail || isString(e.detail) && e.detail !== this.constructor.name) {\n      this.value = e.currentTarget.value;\n    }\n  }\n\n  /**\n   * Tag click event handler\n   *\n   * @param e\n   */\n  _onTagClick(e) {\n    e.preventDefault();\n\n    if (e.currentTarget.classList.contains('delete')) {\n      return false;\n    }\n\n    if (this.container.getAttribute('disabled') !== null || this.container.classList.contains('is-disabled')) {\n      return false;\n    }\n\n    this._input.focus();\n\n    if (this.options.selectable) {\n      const tag = e.currentTarget.closest('.tag');\n\n      if (tag) {\n        const tagIndex = Array.from(this.container.children).indexOf(tag);\n        if (tagIndex === this._selected) {\n          this.clearSelection();\n        } else {\n          this.selectAtIndex(tagIndex);\n        }\n      }\n    }\n  }\n\n  /**\n   * Delete tag button click event handler\n   *\n   * @param e\n   */\n  _onTagDeleteClick(e) {\n    e.preventDefault();\n\n    if (this.container.getAttribute('disabled') !== null || this.container.classList.contains('is-disabled')) {\n      return false;\n    }\n\n    const tag = e.currentTarget.closest('.tag');\n\n    if (tag) {\n      this.removeAtIndex(Array.from(this.container.children).indexOf(tag));\n    }\n  }\n}\n"]}