From 722da8c9d9db779bba146004600abe82c59aab5e Mon Sep 17 00:00:00 2001 From: Jordan Humphreys Date: Thu, 21 Jul 2016 13:37:39 -0700 Subject: [PATCH] Add the dist directory bakc in." --- .gitignore | 1 - dist/tribute.css | 24 + dist/tribute.js | 1353 +++++++++++++++++++++++++++++++++++++++ dist/tribute.min.js | 2 + dist/tribute.min.js.map | 1 + 5 files changed, 1380 insertions(+), 1 deletion(-) create mode 100644 dist/tribute.css create mode 100644 dist/tribute.js create mode 100644 dist/tribute.min.js create mode 100644 dist/tribute.min.js.map diff --git a/.gitignore b/.gitignore index da592f8d..fd4f2b06 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,2 @@ node_modules .DS_Store -dist diff --git a/dist/tribute.css b/dist/tribute.css new file mode 100644 index 00000000..9a4bb39d --- /dev/null +++ b/dist/tribute.css @@ -0,0 +1,24 @@ +.tribute-container { + position: absolute; + top: 0; + left: 0; + height: auto; + max-height: 300px; + max-width: 500px; + overflow: auto; + display: block; + z-index: 999999; } + .tribute-container ul { + margin: 0; + margin-top: 2px; + list-style: none; + background: #efefef; } + .tribute-container li { + padding: 5px 5px; + cursor: pointer; } + .tribute-container li.highlight, .tribute-container li:hover { + background: #ddd; } + .tribute-container li span { + font-weight: bold; } + .tribute-container .menu-highlighted { + font-weight: bold; } diff --git a/dist/tribute.js b/dist/tribute.js new file mode 100644 index 00000000..5fa5d452 --- /dev/null +++ b/dist/tribute.js @@ -0,0 +1,1353 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o', + post: '', + extract: function extract(el) { + return el[_this2.current.collection.lookup]; + } + }); + + this.current.filteredItems = items; + + var ul = this.menu.querySelector('ul'); + + if (!items.length) { + var noMatchEvent = new CustomEvent('tribute-no-match', { detail: this.menu }); + this.current.element.dispatchEvent(noMatchEvent); + if (!this.current.collection.noMatchTemplate) { + this.hideMenu(); + } else { + ul.innerHTML = this.current.collection.noMatchTemplate(); + } + + return; + } + + ul.innerHTML = ''; + + items.forEach(function (item, index) { + var li = _this2.range.getDocument().createElement('li'); + li.setAttribute('data-index', index); + if (_this2.menuSelected === index) { + li.className = _this2.current.collection.selectClass; + } + li.innerHTML = _this2.current.collection.menuItemTemplate(item); + ul.appendChild(li); + }); + + this.range.positionMenuAtCaret(scrollTo); + } + }, { + key: "hideMenu", + value: function hideMenu() { + if (this.menu) { + this.menu.style.cssText = 'display: none;'; + this.isActive = false; + this.menuSelected = 0; + this.current = {}; + } + } + }, { + key: "selectItemAtIndex", + value: function selectItemAtIndex(index) { + index = parseInt(index); + if (typeof index !== 'number') return; + var item = this.current.filteredItems[index]; + var content = this.current.collection.selectTemplate(item); + this.replaceText(content); + } + }, { + key: "replaceText", + value: function replaceText(content) { + this.range.replaceTriggerText(content, true, true); + } + }, { + key: "_append", + value: function _append(collection, element, newValues, replace) { + if (this.isActive) { + if (!replace) { + collection.values = collection.values.concat(newValues); + } else { + collection.values = newValues; + } + } + } + }, { + key: "append", + value: function append(collectionIndex, newValues, replace) { + var index = parseInt(collectionIndex); + if (typeof index !== 'number') throw new Error('please provide an index for the collection to update.'); + + var collection = this.collection[index]; + + this._append(this.current.collection, this.current.element, newValues, replace); + } + }, { + key: "appendCurrent", + value: function appendCurrent(newValues, replace) { + this._append(this.current.collection, this.current.element, newValues, replace); + } + }], [{ + key: "defaultSelectTemplate", + value: function defaultSelectTemplate(item) { + return "@" + item.original[this.current.collection.fillAttr]; + } + }, { + key: "defaultMenuItemTemplate", + value: function defaultMenuItemTemplate(matchItem) { + return matchItem.string; + } + }, { + key: "inputTypes", + value: function inputTypes() { + return ['TEXTAREA', 'INPUT']; + } + }]); + + return Tribute; +}(); + +global.Tribute = Tribute; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) + +},{"./TributeEvents":2,"./TributeMenuEvents":3,"./TributeRange":4,"./TributeSearch":5,"./utils":6}],2:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var TributeEvents = function () { + function TributeEvents(tribute) { + _classCallCheck(this, TributeEvents); + + this.tribute = tribute; + this.tribute.events = this; + } + + _createClass(TributeEvents, [{ + key: 'bind', + value: function bind(element) { + element.addEventListener('keydown', this.keydown.bind(element, this), false); + element.addEventListener('keyup', this.keyup.bind(element, this), false); + element.addEventListener('input', this.input.bind(element, this), false); + } + }, { + key: 'keydown', + value: function keydown(instance, event) { + if (instance.shouldDeactivate(event)) { + instance.tribute.isActive = false; + } + + var element = this; + instance.commandEvent = false; + + TributeEvents.keys().forEach(function (o) { + if (o.key === event.keyCode) { + instance.commandEvent = true; + instance.callbacks()[o.value.toLowerCase()](event, element); + } + }); + } + }, { + key: 'input', + value: function input(instance, event) { + instance.inputEvent = true; + instance.keyup.call(this, instance, event); + } + }, { + key: 'click', + value: function click(instance, event) { + var tribute = instance.tribute; + + if (tribute.menu && tribute.menu.contains(event.target)) { + var li = event.target; + while (li.nodeName.toLowerCase() !== 'li') { + li = li.parentNode; + if (!li || li === tribute.menu) { + throw new Error('cannot find the
  • container for the click'); + } + } + tribute.selectItemAtIndex(li.getAttribute('data-index')); + tribute.hideMenu(); + } else if (tribute.current.element) { + tribute.hideMenu(); + } + } + }, { + key: 'keyup', + value: function keyup(instance, event) { + var _this = this; + + if (instance.inputEvent) { + instance.inputEvent = false; + } + instance.updateSelection(this); + + if (event.keyCode === 27) return; + + if (!instance.tribute.isActive) { + var _ret = function () { + var keyCode = instance.getKeyCode(instance, _this, event); + + if (isNaN(keyCode)) return { + v: void 0 + }; + + var trigger = instance.tribute.triggers().find(function (trigger) { + return trigger.charCodeAt(0) === keyCode; + }); + + if (typeof trigger !== 'undefined') { + instance.callbacks().triggerChar(event, _this, trigger); + } + }(); + + if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v; + } + + if (instance.tribute.current.trigger && instance.commandEvent === false || instance.tribute.isActive && event.keyCode === 8) { + instance.tribute.showMenuFor(this, true); + } + } + }, { + key: 'shouldDeactivate', + value: function shouldDeactivate(event) { + if (!this.tribute.isActive) return false; + + if (this.tribute.current.mentionText.length === 0) { + var eventKeyPressed = false; + TributeEvents.keys().forEach(function (o) { + if (event.keyCode === o.key) eventKeyPressed = true; + }); + + return !eventKeyPressed; + } + + return false; + } + }, { + key: 'getKeyCode', + value: function getKeyCode(instance, el, event) { + var char = void 0; + var tribute = instance.tribute; + var info = tribute.range.getTriggerInfo(false, false, true); + + if (info) { + return info.mentionTriggerChar.charCodeAt(0); + } else { + return false; + } + } + }, { + key: 'updateSelection', + value: function updateSelection(el) { + this.tribute.current.element = el; + var info = this.tribute.range.getTriggerInfo(false, false, true); + + if (info) { + this.tribute.current.selectedPath = info.mentionSelectedPath; + this.tribute.current.mentionText = info.mentionText; + this.tribute.current.selectedOffset = info.mentionSelectedOffset; + } + } + }, { + key: 'callbacks', + value: function callbacks() { + var _this2 = this; + + return { + triggerChar: function triggerChar(e, el, trigger) { + var tribute = _this2.tribute; + tribute.current.trigger = trigger; + + var collectionItem = tribute.collection.find(function (item) { + return item.trigger === trigger; + }); + + tribute.current.collection = collectionItem; + + tribute.showMenuFor(el, true); + }, + enter: function enter(e, el) { + // choose selection + if (_this2.tribute.isActive) { + e.preventDefault(); + setTimeout(function () { + _this2.tribute.selectItemAtIndex(_this2.tribute.menuSelected); + _this2.tribute.hideMenu(); + }, 0); + } + }, + escape: function escape(e, el) { + if (_this2.tribute.isActive) { + e.preventDefault(); + _this2.tribute.hideMenu(); + } + }, + tab: function tab(e, el) { + // choose first match + _this2.callbacks().enter(e, el); + }, + up: function up(e, el) { + // navigate up ul + if (_this2.tribute.isActive) { + e.preventDefault(); + var count = _this2.tribute.current.filteredItems.length, + selected = _this2.tribute.menuSelected; + + if (count > selected && selected > 0) { + _this2.tribute.menuSelected--; + _this2.setActiveLi(); + } + } + }, + down: function down(e, el) { + // navigate down ul + if (_this2.tribute.isActive) { + e.preventDefault(); + var count = _this2.tribute.current.filteredItems.length - 1, + selected = _this2.tribute.menuSelected; + + if (count > selected) { + _this2.tribute.menuSelected++; + _this2.setActiveLi(); + } + } + }, + delete: function _delete(e, el) { + if (_this2.tribute.isActive && _this2.tribute.current.mentionText.length < 1) { + _this2.tribute.hideMenu(); + } else if (_this2.tribute.isActive) { + tribute.showMenuFor(el); + } + } + }; + } + }, { + key: 'setActiveLi', + value: function setActiveLi(index) { + var lis = this.tribute.menu.querySelectorAll('li'), + length = lis.length >>> 0; + + for (var i = 0; i < length; i++) { + var li = lis[i]; + if (i === this.tribute.menuSelected) { + li.className = this.tribute.current.collection.selectClass; + } else { + li.className = ''; + } + } + } + }], [{ + key: 'keys', + value: function keys() { + return [{ + key: 9, + value: 'TAB' + }, { + key: 8, + value: 'DELETE' + }, { + key: 13, + value: 'ENTER' + }, { + key: 27, + value: 'ESCAPE' + }, { + key: 38, + value: 'UP' + }, { + key: 40, + value: 'DOWN' + }]; + } + }]); + + return TributeEvents; +}(); + +exports.default = TributeEvents; + +},{}],3:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +var TributeMenuEvents = function () { + function TributeMenuEvents(tribute) { + _classCallCheck(this, TributeMenuEvents); + + this.tribute = tribute; + this.tribute.menuEvents = this; + this.menu = this.tribute.menu; + } + + _createClass(TributeMenuEvents, [{ + key: 'bind', + value: function bind(menu) { + var _this = this; + + menu.addEventListener('keydown', this.tribute.events.keydown.bind(this.menu, this), false); + this.tribute.range.getDocument().addEventListener('click', this.tribute.events.click.bind(null, this), false); + window.addEventListener('resize', this.debounce(function () { + if (_this.tribute.isActive) { + _this.tribute.showMenuFor(_this.tribute.current.element, true); + } + }, 300, false)); + + if (this.menuContainer) { + this.menuContainer.addEventListener('scroll', this.debounce(function () { + if (_this.tribute.isActive) { + _this.tribute.showMenuFor(_this.tribute.current.element, false); + } + }, 300, false), false); + } else { + window.onscroll = this.debounce(function () { + if (_this.tribute.isActive) { + _this.tribute.showMenuFor(_this.tribute.current.element, false); + } + }, 300, false); + } + } + }, { + key: 'debounce', + value: function debounce(func, wait, immediate) { + var _this2 = this, + _arguments = arguments; + + var timeout; + return function () { + var context = _this2, + args = _arguments; + var later = function later() { + timeout = null; + if (!immediate) func.apply(context, args); + }; + var callNow = immediate && !timeout; + clearTimeout(timeout); + timeout = setTimeout(later, wait); + if (callNow) func.apply(context, args); + }; + } + }]); + + return TributeMenuEvents; +}(); + +exports.default = TributeMenuEvents; + +},{}],4:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +// Thanks to https://github.com/jeff-collins/ment.io + +var TributeRange = function () { + function TributeRange(tribute) { + _classCallCheck(this, TributeRange); + + this.tribute = tribute; + this.tribute.range = this; + } + + _createClass(TributeRange, [{ + key: 'getDocument', + value: function getDocument() { + var iframe = void 0; + if (this.tribute.current.collection) { + iframe = this.tribute.current.collection.iframe; + } + + if (!iframe) { + return document; + } + + return iframe.contentWindow.document; + } + }, { + key: 'positionMenuAtCaret', + value: function positionMenuAtCaret(scrollTo) { + var _this = this; + + var context = this.tribute.current, + coordinates = void 0; + var info = this.getTriggerInfo(false, false, true); + + if (info !== undefined) { + if (!this.isContentEditable(context.element)) { + coordinates = this.getTextAreaOrInputUnderlinePosition(this.getDocument().activeElement, info.mentionPosition); + } else { + coordinates = this.getContentEditableCaretPosition(info.mentionPosition); + } + + // Move the button into place. + this.tribute.menu.style.cssText = 'top: ' + coordinates.top + 'px;\n left: ' + coordinates.left + 'px;\n position: absolute;\n zIndex: 10000;\n display: block;'; + + setTimeout(function () { + if (scrollTo) _this.scrollIntoView(_this.getDocument().activeElement); + }, 0); + } else { + this.tribute.menu.style.cssText = 'display: none'; + } + } + }, { + key: 'selectElement', + value: function selectElement(targetElement, path, offset) { + var range = void 0; + var elem = targetElement; + + if (path) { + for (var i = 0; i < path.length; i++) { + elem = elem.childNodes[path[i]]; + if (elem === undefined) { + return; + } + while (elem.length < offset) { + offset -= elem.length; + elem = elem.nextSibling; + } + if (elem.childNodes.length === 0 && !elem.length) { + elem = elem.previousSibling; + } + } + } + var sel = this.getWindowSelection(); + + range = this.getDocument().createRange(); + range.setStart(elem, offset); + range.setEnd(elem, offset); + range.collapse(true); + + try { + sel.removeAllRanges(); + } catch (error) {} + + sel.addRange(range); + targetElement.focus(); + } + }, { + key: 'resetSelection', + value: function resetSelection(targetElement, path, offset) { + if (!this.isContentEditable(targetElement)) { + if (targetElement !== this.getDocument().activeElement) { + targetElement.focus(); + } + } else { + this.selectElement(targetElement, path, offset); + } + } + }, { + key: 'replaceTriggerText', + value: function replaceTriggerText(text, requireLeadingSpace, hasTrailingSpace) { + var context = this.tribute.current; + this.resetSelection(context.element, context.selectedPath, context.selectedOffset); + + var info = this.getTriggerInfo(requireLeadingSpace, true, hasTrailingSpace); + + // Create the event + var replaceEvent = new CustomEvent('tribute-replaced', { + detail: text + }); + + if (info !== undefined) { + if (!this.isContentEditable(context.element)) { + var myField = this.getDocument().activeElement; + text += ' '; + var startPos = info.mentionPosition; + var endPos = info.mentionPosition + info.mentionText.length + 1; + myField.value = myField.value.substring(0, startPos) + text + myField.value.substring(endPos, myField.value.length); + myField.selectionStart = startPos + text.length; + myField.selectionEnd = startPos + text.length; + } else { + // add a space to the end of the pasted text + text += '\xA0'; + this.pasteHtml(text, info.mentionPosition, info.mentionPosition + info.mentionText.length + 1); + } + + context.element.dispatchEvent(replaceEvent); + } + } + }, { + key: 'pasteHtml', + value: function pasteHtml(html, startPos, endPos) { + var range = void 0, + sel = void 0; + sel = this.getWindowSelection(); + range = this.getDocument().createRange(); + range.setStart(sel.anchorNode, startPos); + range.setEnd(sel.anchorNode, endPos); + range.deleteContents(); + + var el = this.getDocument().createElement('div'); + el.innerHTML = html; + var frag = this.getDocument().createDocumentFragment(), + node = void 0, + lastNode = void 0; + while (node = el.firstChild) { + lastNode = frag.appendChild(node); + } + range.insertNode(frag); + + // Preserve the selection + if (lastNode) { + range = range.cloneRange(); + range.setStartAfter(lastNode); + range.collapse(true); + sel.removeAllRanges(); + sel.addRange(range); + } + } + }, { + key: 'getWindowSelection', + value: function getWindowSelection() { + if (this.tribute.collection.iframe) { + return this.tribute.collection.iframe.contentWindow.getSelection(); + } + + return window.getSelection(); + } + }, { + key: 'getNodePositionInParent', + value: function getNodePositionInParent(element) { + if (element.parentNode === null) { + return 0; + } + + for (var i = 0; i < element.parentNode.childNodes.length; i++) { + var node = element.parentNode.childNodes[i]; + + if (node === element) { + return i; + } + } + } + }, { + key: 'getContentEditableSelectedPath', + value: function getContentEditableSelectedPath() { + // content editable + var sel = this.getWindowSelection(); + var selected = sel.anchorNode; + var path = []; + var offset = void 0; + + if (selected != null) { + var i = void 0; + var ce = selected.contentEditable; + while (selected !== null && ce !== 'true') { + i = this.getNodePositionInParent(selected); + path.push(i); + selected = selected.parentNode; + if (selected !== null) { + ce = selected.contentEditable; + } + } + path.reverse(); + + // getRangeAt may not exist, need alternative + offset = sel.getRangeAt(0).startOffset; + + return { + selected: selected, + path: path, + offset: offset + }; + } + } + }, { + key: 'getTextPrecedingCurrentSelection', + value: function getTextPrecedingCurrentSelection() { + var context = this.tribute.current, + text = void 0; + + if (!this.isContentEditable(context.element)) { + var textComponent = this.getDocument().activeElement; + var startPos = textComponent.selectionStart; + text = textComponent.value.substring(0, startPos); + } else { + var selectedElem = this.getWindowSelection().anchorNode; + + if (selectedElem != null) { + var workingNodeContent = selectedElem.textContent; + var selectStartOffset = this.getWindowSelection().getRangeAt(0).startOffset; + + if (selectStartOffset >= 0) { + text = workingNodeContent.substring(0, selectStartOffset); + } + } + } + + return text; + } + }, { + key: 'getTriggerInfo', + value: function getTriggerInfo(menuAlreadyActive, hasTrailingSpace, requireLeadingSpace) { + var _this2 = this; + + var ctx = this.tribute.current; + var selected = void 0, + path = void 0, + offset = void 0; + + if (!this.isContentEditable(ctx.element)) { + selected = this.getDocument().activeElement; + } else { + // content editable + var selectionInfo = this.getContentEditableSelectedPath(); + + if (selectionInfo) { + selected = selectionInfo.selected; + path = selectionInfo.path; + offset = selectionInfo.offset; + } + } + + var effectiveRange = this.getTextPrecedingCurrentSelection(); + + if (effectiveRange !== undefined && effectiveRange !== null) { + var _ret = function () { + var mostRecentTriggerCharPos = -1; + var triggerChar = void 0; + + _this2.tribute.triggers().forEach(function (c) { + var idx = effectiveRange.lastIndexOf(c); + + if (idx > mostRecentTriggerCharPos) { + mostRecentTriggerCharPos = idx; + triggerChar = c; + } + }); + + if (mostRecentTriggerCharPos >= 0 && (mostRecentTriggerCharPos === 0 || !requireLeadingSpace || /[\xA0\s]/g.test(effectiveRange.substring(mostRecentTriggerCharPos - 1, mostRecentTriggerCharPos)))) { + var currentTriggerSnippet = effectiveRange.substring(mostRecentTriggerCharPos + 1, effectiveRange.length); + + triggerChar = effectiveRange.substring(mostRecentTriggerCharPos, mostRecentTriggerCharPos + 1); + var firstSnippetChar = currentTriggerSnippet.substring(0, 1); + var leadingSpace = currentTriggerSnippet.length > 0 && (firstSnippetChar === ' ' || firstSnippetChar === '\xA0'); + if (hasTrailingSpace) { + currentTriggerSnippet = currentTriggerSnippet.trim(); + } + if (!leadingSpace && (menuAlreadyActive || !/[\xA0\s]/g.test(currentTriggerSnippet))) { + return { + v: { + mentionPosition: mostRecentTriggerCharPos, + mentionText: currentTriggerSnippet, + mentionSelectedElement: selected, + mentionSelectedPath: path, + mentionSelectedOffset: offset, + mentionTriggerChar: triggerChar + } + }; + } + } + }(); + + if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v; + } + } + }, { + key: 'isContentEditable', + value: function isContentEditable(element) { + return element.nodeName !== 'INPUT' && element.nodeName !== 'TEXTAREA'; + } + }, { + key: 'getTextAreaOrInputUnderlinePosition', + value: function getTextAreaOrInputUnderlinePosition(element, position) { + var properties = ['direction', 'boxSizing', 'width', 'height', 'overflowX', 'overflowY', 'borderTopWidth', 'borderRightWidth', 'borderBottomWidth', 'borderLeftWidth', 'paddingTop', 'paddingRight', 'paddingBottom', 'paddingLeft', 'fontStyle', 'fontVariant', 'fontWeight', 'fontStretch', 'fontSize', 'fontSizeAdjust', 'lineHeight', 'fontFamily', 'textAlign', 'textTransform', 'textIndent', 'textDecoration', 'letterSpacing', 'wordSpacing']; + + var isFirefox = window.mozInnerScreenX !== null; + + var div = this.getDocument().createElement('div'); + div.id = 'input-textarea-caret-position-mirror-div'; + this.getDocument().body.appendChild(div); + + var style = div.style; + var computed = window.getComputedStyle ? getComputedStyle(element) : element.currentStyle; + + style.whiteSpace = 'pre-wrap'; + if (element.nodeName !== 'INPUT') { + style.wordWrap = 'break-word'; + } + + // position off-screen + style.position = 'absolute'; + style.visibility = 'hidden'; + + // transfer the element's properties to the div + properties.forEach(function (prop) { + style[prop] = computed[prop]; + }); + + if (isFirefox) { + style.width = parseInt(computed.width) - 2 + 'px'; + if (element.scrollHeight > parseInt(computed.height)) style.overflowY = 'scroll'; + } else { + style.overflow = 'hidden'; + } + + div.textContent = element.value.substring(0, position); + + if (element.nodeName === 'INPUT') { + div.textContent = div.textContent.replace(/\s/g, ' '); + } + + var span = this.getDocument().createElement('span'); + span.textContent = element.value.substring(position) || '.'; + div.appendChild(span); + + var rect = element.getBoundingClientRect(); + var doc = document.documentElement; + var windowLeft = (window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0); + var windowTop = (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0); + + var coordinates = { + top: rect.top + windowTop + span.offsetTop + parseInt(computed.borderTopWidth) + parseInt(computed.fontSize), + left: rect.left + windowLeft + span.offsetLeft + parseInt(computed.borderLeftWidth) + }; + + this.getDocument().body.removeChild(div); + + return coordinates; + } + }, { + key: 'getContentEditableCaretPosition', + value: function getContentEditableCaretPosition(selectedNodePosition) { + var markerTextChar = ''; + var markerEl = void 0, + markerId = 'sel_' + new Date().getTime() + '_' + Math.random().toString().substr(2); + var range = void 0; + var sel = this.getWindowSelection(); + var prevRange = sel.getRangeAt(0); + + range = this.getDocument().createRange(); + range.setStart(sel.anchorNode, selectedNodePosition); + range.setEnd(sel.anchorNode, selectedNodePosition); + + range.collapse(false); + + // Create the marker element containing a single invisible character using DOM methods and insert it + markerEl = this.getDocument().createElement('span'); + markerEl.id = markerId; + markerEl.appendChild(this.getDocument().createTextNode(markerTextChar)); + range.insertNode(markerEl); + sel.removeAllRanges(); + sel.addRange(prevRange); + + var rect = markerEl.getBoundingClientRect(); + var doc = document.documentElement; + var windowLeft = (window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0); + var windowTop = (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0); + var coordinates = { + left: rect.left + windowLeft, + top: rect.top + markerEl.offsetHeight + windowTop + }; + + markerEl.parentNode.removeChild(markerEl); + return coordinates; + } + }, { + key: 'scrollIntoView', + value: function scrollIntoView(elem) { + var reasonableBuffer = 20, + clientRect = void 0; + var maxScrollDisplacement = 100; + var e = elem; + + while (clientRect === undefined || clientRect.height === 0) { + clientRect = e.getBoundingClientRect(); + + if (clientRect.height === 0) { + e = e.childNodes[0]; + if (e === undefined || !e.getBoundingClientRect) { + return; + } + } + } + + var elemTop = clientRect.top; + var elemBottom = elemTop + clientRect.height; + + if (elemTop < 0) { + window.scrollTo(0, window.pageYOffset + clientRect.top - reasonableBuffer); + } else if (elemBottom > window.innerHeight) { + var maxY = window.pageYOffset + clientRect.top - reasonableBuffer; + + if (maxY - window.pageYOffset > maxScrollDisplacement) { + maxY = window.pageYOffset + maxScrollDisplacement; + } + + var targetY = window.pageYOffset - (window.innerHeight - elemBottom); + + if (targetY > maxY) { + targetY = maxY; + } + + window.scrollTo(0, targetY); + } + } + }]); + + return TributeRange; +}(); + +exports.default = TributeRange; + +},{}],5:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +// Thanks to https://github.com/mattyork/fuzzy + +var TributeSearch = function () { + function TributeSearch(tribute) { + _classCallCheck(this, TributeSearch); + + this.tribute = tribute; + this.tribute.search = this; + } + + _createClass(TributeSearch, [{ + key: 'simpleFilter', + value: function simpleFilter(pattern, array) { + var _this = this; + + return array.filter(function (string) { + return _this.test(pattern, string); + }); + } + }, { + key: 'test', + value: function test(pattern, string) { + return this.match(pattern, string) !== null; + } + }, { + key: 'match', + value: function match(pattern, string, opts) { + opts = opts || {}; + var patternIdx = 0, + result = [], + len = string.length, + totalScore = 0, + currScore = 0, + pre = opts.pre || '', + post = opts.post || '', + compareString = opts.caseSensitive && string || string.toLowerCase(), + ch = void 0, + compareChar = void 0; + + pattern = opts.caseSensitive && pattern || pattern.toLowerCase(); + + var patternCache = this.traverse(compareString, pattern, 0, 0, []); + if (!patternCache) { + return null; + } + + return { + rendered: this.render(string, patternCache.cache, pre, post), + score: patternCache.score + }; + } + }, { + key: 'traverse', + value: function traverse(string, pattern, stringIndex, patternIndex, patternCache) { + // if the pattern search at end + if (pattern.length === patternIndex) { + + // calculate socre and copy the cache containing the indices where it's found + return { + score: this.calculateScore(patternCache), + cache: patternCache.slice() + }; + } + + // if string at end or remaining pattern > remaining string + if (string.length === stringIndex || pattern.length - patternIndex > string.length - stringIndex) { + return undefined; + } + + var c = pattern[patternIndex]; + var index = string.indexOf(c, stringIndex); + var best = void 0, + temp = void 0; + + while (index > -1) { + patternCache.push(index); + temp = this.traverse(string, pattern, index + 1, patternIndex + 1, patternCache); + patternCache.pop(); + + // if downstream traversal failed, return best answer so far + if (!temp) { + return best; + } + + if (!best || best.score < temp.score) { + best = temp; + } + + index = string.indexOf(c, index + 1); + } + + return best; + } + }, { + key: 'calculateScore', + value: function calculateScore(patternCache) { + var score = 0; + var temp = 1; + + patternCache.forEach(function (index, i) { + if (i > 0) { + if (patternCache[i - 1] + 1 === index) { + temp += temp + 1; + } else { + temp = 1; + } + } + + score += temp; + }); + + return score; + } + }, { + key: 'render', + value: function render(string, indices, pre, post) { + var rendered = string.substring(0, indices[0]); + + indices.forEach(function (index, i) { + rendered += pre + string[index] + post + string.substring(index + 1, indices[i + 1] ? indices[i + 1] : string.length); + }); + + return rendered; + } + }, { + key: 'filter', + value: function filter(pattern, arr, opts) { + var _this2 = this; + + opts = opts || {}; + return arr.reduce(function (prev, element, idx, arr) { + var str = element; + + if (opts.extract) { + str = opts.extract(element); + + if (!str) { + // take care of undefineds / nulls / etc. + str = ''; + } + } + + var rendered = _this2.match(pattern, str, opts); + + if (rendered != null) { + prev[prev.length] = { + string: rendered.rendered, + score: rendered.score, + index: idx, + original: element + }; + } + + return prev; + }, []).sort(function (a, b) { + var compare = b.score - a.score; + if (compare) return compare; + return a.index - b.index; + }); + } + }]); + + return TributeSearch; +}(); + +exports.default = TributeSearch; + +},{}],6:[function(require,module,exports){ +'use strict'; + +if (!Array.prototype.find) { + Array.prototype.find = function (predicate) { + if (this === null) { + throw new TypeError('Array.prototype.find called on null or undefined'); + } + if (typeof predicate !== 'function') { + throw new TypeError('predicate must be a function'); + } + var list = Object(this); + var length = list.length >>> 0; + var thisArg = arguments[1]; + var value; + + for (var i = 0; i < length; i++) { + value = list[i]; + if (predicate.call(thisArg, value, i, list)) { + return value; + } + } + return undefined; + }; +} + +(function () { + + if (typeof window.CustomEvent === "function") return false; + + function CustomEvent(event, params) { + params = params || { + bubbles: false, + cancelable: false, + detail: undefined + }; + var evt = document.createEvent('CustomEvent'); + evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail); + return evt; + } + + CustomEvent.prototype = window.Event.prototype; + + window.CustomEvent = CustomEvent; +})(); + +},{}]},{},[1]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","src/Tribute.js","src/TributeEvents.js","src/TributeMenuEvents.js","src/TributeRange.js","src/TributeSearch.js","src/utils.js"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","import \"./utils\";\nimport TributeEvents from \"./TributeEvents\";\nimport TributeMenuEvents from \"./TributeMenuEvents\";\nimport TributeRange from \"./TributeRange\";\nimport TributeSearch from \"./TributeSearch\";\n\nclass Tribute {\n    constructor({\n        values = null,\n        iframe = null,\n        selectClass = 'highlight',\n        trigger = '@',\n        selectTemplate = null,\n        menuItemTemplate = null,\n        lookup = 'key',\n        fillAttr = 'value',\n        collection = null,\n        menuContainer = null,\n        noMatchTemplate = null\n    }) {\n\n        this.menuSelected = 0\n        this.current = {}\n        this.inputEvent = false\n        this.isActive = false\n        this.menuContainer = menuContainer\n\n        if (values) {\n            this.collection = [{\n                // symbol that starts the lookup\n                trigger: trigger,\n\n                iframe: iframe,\n\n                selectClass: selectClass,\n\n                // function called on select that retuns the content to insert\n                selectTemplate: (selectTemplate || Tribute.defaultSelectTemplate).bind(this),\n\n                // function called that returns content for an item\n                menuItemTemplate: (menuItemTemplate || Tribute.defaultMenuItemTemplate).bind(this),\n\n                // function called when menu is empty, disables hiding of menu.\n                noMatchTemplate: (t => {\n                    if (typeof t === 'function') {\n                        return t.bind(this)\n                    }\n\n                    return null\n                })(noMatchTemplate),\n\n                // column to search against in the object\n                lookup: lookup,\n\n                // column that contains the content to insert by default\n                fillAttr: fillAttr,\n\n                // array of objects\n                values: values\n            }]\n        }\n        else if (collection) {\n            this.collection = collection.map(item => {\n                return {\n                    trigger: item.trigger || trigger,\n                    iframe: item.iframe || iframe,\n                    selectClass: item.selectClass || selectClass,\n                    selectTemplate: (item.selectTemplate || Tribute.defaultSelectTemplate).bind(this),\n                    menuItemTemplate: (item.menuItemTemplate || Tribute.defaultMenuItemTemplate).bind(this),\n                    // function called when menu is empty, disables hiding of menu.\n                    noMatchTemplate: (t => {\n                        if (typeof t === 'function') {\n                            return t.bind(this)\n                        }\n\n                        return null\n                    })(noMatchTemplate),\n                    lookup: item.lookup || lookup,\n                    fillAttr: item.fillAttr || fillAttr,\n                    values: item.values\n                }\n            })\n        }\n        else {\n            throw new Error('[Tribute] No collection specified.')\n        }\n\n        new TributeRange(this);\n        new TributeEvents(this);\n        new TributeMenuEvents(this);\n        new TributeSearch(this);\n    }\n\n    static defaultSelectTemplate(item) {\n        return `@${item.original[this.current.collection.fillAttr]}`\n    }\n\n    static defaultMenuItemTemplate(matchItem) {\n        return matchItem.string\n    }\n\n    static inputTypes() {\n        return ['TEXTAREA', 'INPUT']\n    }\n\n    triggers() {\n        return this.collection.map(config => {\n            return config.trigger\n        })\n    }\n\n    attach(el) {\n        if (!el) {\n            throw new Error('[Tribute] Must pass in a DOM node or NodeList.')\n        }\n\n        // Check if it is a jQuery collection\n        if (typeof jQuery !== 'undefined' && el instanceof jQuery) {\n            el = el.get()\n        }\n\n        // Is el an Array/Array-like object?\n        if (el.constructor === NodeList || el.constructor === HTMLCollection || el.constructor === Array) {\n            let length = el.length\n            for (var i = 0; i < length; ++i) {\n                this._attach(el[i])\n            }\n        }\n        else {\n            this._attach(el)\n        }\n    }\n\n    _attach(el) {\n        if (el.hasAttribute('data-tribute')) {\n            console.warn('Tribute was already bound to ' + el.nodeName)\n        }\n\n        this.ensureEditable(el)\n        this.events.bind(el)\n        el.setAttribute('data-tribute', true)\n    }\n\n    ensureEditable(element) {\n        if (Tribute.inputTypes().indexOf(element.nodeName) === -1) {\n            if (element.contentEditable) {\n                element.contentEditable = true\n            }\n            else {\n                throw new Error('[Tribute] Cannot bind to ' + element.nodeName)\n            }\n        }\n    }\n\n    createMenu() {\n        let wrapper = this.range.getDocument().createElement('div'),\n            ul = this.range.getDocument().createElement('ul')\n\n        wrapper.className = 'tribute-container'\n        wrapper.appendChild(ul)\n\n        if (this.menuContainer) {\n            return this.menuContainer.appendChild(wrapper)\n        }\n\n        return this.range.getDocument().body.appendChild(wrapper)\n    }\n\n    showMenuFor(element, scrollTo) {\n        let items\n            // create the menu if it doesn't exist.\n        if (!this.menu) {\n            this.menu = this.createMenu()\n            this.menuEvents.bind(this.menu)\n        }\n\n        this.isActive = true\n        this.menuSelected = 0\n\n        if (!this.current.mentionText) {\n            this.current.mentionText = ''\n        }\n\n        items = this.search.filter(this.current.mentionText, this.current.collection.values, {\n            pre: '<span>',\n            post: '</span>',\n            extract: (el) => {\n                return el[this.current.collection.lookup]\n            }\n        })\n\n        this.current.filteredItems = items\n\n        let ul = this.menu.querySelector('ul')\n\n        if (!items.length) {\n            let noMatchEvent = new CustomEvent('tribute-no-match', { detail: this.menu })\n            this.current.element.dispatchEvent(noMatchEvent)\n            if (!this.current.collection.noMatchTemplate) {\n                this.hideMenu()\n            } else {\n                ul.innerHTML = this.current.collection.noMatchTemplate()\n            }\n\n            return\n        }\n\n        ul.innerHTML = ''\n\n        items.forEach((item, index) => {\n            let li = this.range.getDocument().createElement('li')\n            li.setAttribute('data-index', index)\n            if (this.menuSelected === index) {\n                li.className = this.current.collection.selectClass\n            }\n            li.innerHTML = this.current.collection.menuItemTemplate(item)\n            ul.appendChild(li)\n        })\n\n        this.range.positionMenuAtCaret(scrollTo)\n\n    }\n\n    hideMenu() {\n        if (this.menu) {\n            this.menu.style.cssText = 'display: none;'\n            this.isActive = false\n            this.menuSelected = 0\n            this.current = {}\n        }\n    }\n\n    selectItemAtIndex(index) {\n        index = parseInt(index)\n        if (typeof index !== 'number') return\n        let item = this.current.filteredItems[index]\n        let content = this.current.collection.selectTemplate(item)\n        this.replaceText(content)\n    }\n\n    replaceText(content) {\n        this.range.replaceTriggerText(content, true, true)\n    }\n\n    _append(collection, element, newValues, replace) {\n        if (this.isActive) {\n            if (!replace) {\n                collection.values = collection.values.concat(newValues)\n            } else {\n                collection.values = newValues\n            }\n        }\n    }\n\n    append(collectionIndex, newValues, replace) {\n        let index = parseInt(collectionIndex)\n        if (typeof index !== 'number') throw new Error('please provide an index for the collection to update.')\n\n        let collection = this.collection[index]\n\n        this._append(this.current.collection, this.current.element, newValues, replace)\n    }\n\n    appendCurrent(newValues, replace) {\n        this._append(this.current.collection, this.current.element, newValues, replace)\n    }\n}\n\nglobal.Tribute = Tribute;\n","class TributeEvents {\n    constructor(tribute) {\n        this.tribute = tribute\n        this.tribute.events = this\n    }\n\n    static keys() {\n        return [{\n            key: 9,\n            value: 'TAB'\n        }, {\n            key: 8,\n            value: 'DELETE'\n        }, {\n            key: 13,\n            value: 'ENTER'\n        }, {\n            key: 27,\n            value: 'ESCAPE'\n        }, {\n            key: 38,\n            value: 'UP'\n        }, {\n            key: 40,\n            value: 'DOWN'\n        }]\n    }\n\n    bind(element) {\n        element.addEventListener('keydown',\n            this.keydown.bind(element, this), false)\n        element.addEventListener('keyup',\n            this.keyup.bind(element, this), false)\n        element.addEventListener('input',\n            this.input.bind(element, this), false)\n    }\n\n    keydown(instance, event) {\n        if (instance.shouldDeactivate(event)) {\n            instance.tribute.isActive = false\n        }\n\n        let element = this\n        instance.commandEvent = false\n\n        TributeEvents.keys().forEach(o => {\n            if (o.key === event.keyCode) {\n                instance.commandEvent = true\n                instance.callbacks()[o.value.toLowerCase()](event, element)\n            }\n        })\n    }\n\n    input(instance, event) {\n        instance.inputEvent = true\n        instance.keyup.call(this, instance, event)\n    }\n\n    click(instance, event) {\n        let tribute = instance.tribute\n\n        if (tribute.menu && tribute.menu.contains(event.target)) {\n            let li = event.target\n            while (li.nodeName.toLowerCase() !== 'li') {\n                li = li.parentNode\n                if (!li || li === tribute.menu) {\n                    throw new Error('cannot find the <li> container for the click')\n                }\n            }\n            tribute.selectItemAtIndex(li.getAttribute('data-index'))\n            tribute.hideMenu()\n        }\n        else if (tribute.current.element) {\n            tribute.hideMenu()\n        }\n    }\n\n    keyup(instance, event) {\n        if (instance.inputEvent) {\n            instance.inputEvent = false\n        }\n        instance.updateSelection(this)\n\n        if (event.keyCode === 27) return\n\n        if (!instance.tribute.isActive) {\n            let keyCode = instance.getKeyCode(instance, this, event)\n\n            if (isNaN(keyCode)) return\n\n            let trigger = instance.tribute.triggers().find(trigger => {\n                return trigger.charCodeAt(0) === keyCode\n            })\n\n            if (typeof trigger !== 'undefined') {\n                instance.callbacks().triggerChar(event, this, trigger)\n            }\n        }\n\n        if (instance.tribute.current.trigger && instance.commandEvent === false\n            || instance.tribute.isActive && event.keyCode === 8) {\n            instance.tribute.showMenuFor(this, true)\n        }\n    }\n\n    shouldDeactivate(event) {\n        if (!this.tribute.isActive) return false\n\n        if (this.tribute.current.mentionText.length === 0) {\n            let eventKeyPressed = false\n            TributeEvents.keys().forEach(o => {\n                if (event.keyCode === o.key) eventKeyPressed = true\n            })\n\n            return !eventKeyPressed\n        }\n\n        return false\n    }\n\n    getKeyCode(instance, el, event) {\n        let char\n        let tribute = instance.tribute\n        let info = tribute.range.getTriggerInfo(false, false, true)\n\n        if (info) {\n            return info.mentionTriggerChar.charCodeAt(0)\n        }\n        else {\n            return false\n        }\n    }\n\n    updateSelection(el) {\n        this.tribute.current.element = el\n        let info = this.tribute.range.getTriggerInfo(false, false, true)\n\n        if (info) {\n            this.tribute.current.selectedPath = info.mentionSelectedPath\n            this.tribute.current.mentionText = info.mentionText\n            this.tribute.current.selectedOffset = info.mentionSelectedOffset\n        }\n    }\n\n    callbacks() {\n        return {\n            triggerChar: (e, el, trigger) => {\n                let tribute = this.tribute\n                tribute.current.trigger = trigger\n\n                let collectionItem = tribute.collection.find(item => {\n                    return item.trigger === trigger\n                })\n\n                tribute.current.collection = collectionItem\n\n                tribute.showMenuFor(el, true)\n            },\n            enter: (e, el) => {\n                // choose selection\n                if (this.tribute.isActive) {\n                    e.preventDefault()\n                    setTimeout(() => {\n                        this.tribute.selectItemAtIndex(this.tribute.menuSelected)\n                        this.tribute.hideMenu()\n                    }, 0)\n                }\n            },\n            escape: (e, el) => {\n                if (this.tribute.isActive) {\n                    e.preventDefault()\n                    this.tribute.hideMenu()\n                }\n            },\n            tab: (e, el) => {\n                // choose first match\n                this.callbacks().enter(e, el)\n            },\n            up: (e, el) => {\n                // navigate up ul\n                if (this.tribute.isActive) {\n                    e.preventDefault()\n                    let count = this.tribute.current.filteredItems.length,\n                        selected = this.tribute.menuSelected\n\n                    if (count > selected && selected > 0) {\n                        this.tribute.menuSelected--\n                            this.setActiveLi()\n                    }\n                }\n            },\n            down: (e, el) => {\n                // navigate down ul\n                if (this.tribute.isActive) {\n                    e.preventDefault()\n                    let count = this.tribute.current.filteredItems.length - 1,\n                        selected = this.tribute.menuSelected\n\n                    if (count > selected) {\n                        this.tribute.menuSelected++\n                            this.setActiveLi()\n                    }\n                }\n            },\n            delete: (e, el) => {\n                if (this.tribute.isActive && this.tribute.current.mentionText.length < 1) {\n                    this.tribute.hideMenu();\n                } else if (this.tribute.isActive) {\n                    tribute.showMenuFor(el)\n                }\n            }\n        }\n    }\n\n    setActiveLi(index) {\n        let lis = this.tribute.menu.querySelectorAll('li'),\n            length = lis.length >>> 0\n\n        for (let i = 0; i < length; i++) {\n            let li = lis[i]\n            if (i === this.tribute.menuSelected) {\n                li.className = this.tribute.current.collection.selectClass\n            }\n            else {\n                li.className = ''\n            }\n        }\n    }\n\n}\n\n\nexport default TributeEvents;\n","class TributeMenuEvents {\n    constructor(tribute) {\n        this.tribute = tribute\n        this.tribute.menuEvents = this\n        this.menu = this.tribute.menu\n    }\n\n    bind(menu) {\n        menu.addEventListener('keydown',\n            this.tribute.events.keydown.bind(this.menu, this), false)\n        this.tribute.range.getDocument().addEventListener('click',\n            this.tribute.events.click.bind(null, this), false)\n        window.addEventListener('resize', this.debounce(() => {\n            if (this.tribute.isActive) {\n                this.tribute.showMenuFor(this.tribute.current.element, true)\n            }\n        }, 300, false))\n\n        if (this.menuContainer) {\n            this.menuContainer.addEventListener('scroll', this.debounce(() => {\n                if (this.tribute.isActive) {\n                    this.tribute.showMenuFor(this.tribute.current.element, false)\n                }\n            }, 300, false), false)\n        }\n        else {\n            window.onscroll = this.debounce(() => {\n                if (this.tribute.isActive) {\n                    this.tribute.showMenuFor(this.tribute.current.element, false)\n                }\n            }, 300, false)\n        }\n\n    }\n\n    debounce(func, wait, immediate) {\n        var timeout\n        return () => {\n            var context = this,\n                args = arguments\n            var later = () => {\n                timeout = null\n                if (!immediate) func.apply(context, args)\n            }\n            var callNow = immediate && !timeout\n            clearTimeout(timeout)\n            timeout = setTimeout(later, wait)\n            if (callNow) func.apply(context, args)\n        }\n    }\n}\n\n\nexport default TributeMenuEvents;","// Thanks to https://github.com/jeff-collins/ment.io\nclass TributeRange {\n    constructor(tribute) {\n        this.tribute = tribute\n        this.tribute.range = this\n    }\n\n    getDocument() {\n        let iframe\n        if (this.tribute.current.collection) {\n            iframe = this.tribute.current.collection.iframe\n        }\n\n        if (!iframe) {\n            return document\n        }\n\n        return iframe.contentWindow.document\n    }\n\n    positionMenuAtCaret(scrollTo) {\n        let context = this.tribute.current,\n            coordinates\n        let info = this.getTriggerInfo(false, false, true)\n\n        if (info !== undefined) {\n            if (!this.isContentEditable(context.element)) {\n                coordinates = this.getTextAreaOrInputUnderlinePosition(this.getDocument().activeElement,\n                    info.mentionPosition)\n            }\n            else {\n                coordinates = this.getContentEditableCaretPosition(info.mentionPosition)\n            }\n\n            // Move the button into place.\n            this.tribute.menu.style.cssText = `top: ${coordinates.top}px;\n                                       left: ${coordinates.left}px;\n                                       position: absolute;\n                                       zIndex: 10000;\n                                       display: block;`\n\n            setTimeout(() => {\n                if (scrollTo) this.scrollIntoView(this.getDocument().activeElement)\n            }, 0)\n        }\n        else {\n            this.tribute.menu.style.cssText = 'display: none'\n        }\n    }\n\n    selectElement(targetElement, path, offset) {\n        let range\n        let elem = targetElement\n\n        if (path) {\n            for (var i = 0; i < path.length; i++) {\n                elem = elem.childNodes[path[i]]\n                if (elem === undefined) {\n                    return\n                }\n                while (elem.length < offset) {\n                    offset -= elem.length\n                    elem = elem.nextSibling\n                }\n                if (elem.childNodes.length === 0 && !elem.length) {\n                    elem = elem.previousSibling\n                }\n            }\n        }\n        let sel = this.getWindowSelection()\n\n        range = this.getDocument().createRange()\n        range.setStart(elem, offset)\n        range.setEnd(elem, offset)\n        range.collapse(true)\n\n        try {\n            sel.removeAllRanges()\n        }\n        catch (error) {}\n\n        sel.addRange(range)\n        targetElement.focus()\n    }\n\n    resetSelection(targetElement, path, offset) {\n        if (!this.isContentEditable(targetElement)) {\n            if (targetElement !== this.getDocument().activeElement) {\n                targetElement.focus()\n            }\n        }\n        else {\n            this.selectElement(targetElement, path, offset)\n        }\n    }\n\n    replaceTriggerText(text, requireLeadingSpace, hasTrailingSpace) {\n        let context = this.tribute.current\n        this.resetSelection(context.element, context.selectedPath, context.selectedOffset)\n\n        let info = this.getTriggerInfo(requireLeadingSpace, true, hasTrailingSpace)\n\n        // Create the event\n        let replaceEvent = new CustomEvent('tribute-replaced', {\n            detail: text\n        })\n\n        if (info !== undefined) {\n            if (!this.isContentEditable(context.element)) {\n                let myField = this.getDocument().activeElement\n                text += ' '\n                let startPos = info.mentionPosition\n                let endPos = info.mentionPosition + info.mentionText.length + 1\n                myField.value = myField.value.substring(0, startPos) + text +\n                    myField.value.substring(endPos, myField.value.length)\n                myField.selectionStart = startPos + text.length\n                myField.selectionEnd = startPos + text.length\n            }\n            else {\n                // add a space to the end of the pasted text\n                text += '\\xA0'\n                this.pasteHtml(text, info.mentionPosition,\n                    info.mentionPosition + info.mentionText.length + 1)\n            }\n\n            context.element.dispatchEvent(replaceEvent)\n        }\n    }\n\n    pasteHtml(html, startPos, endPos) {\n        let range, sel\n        sel = this.getWindowSelection()\n        range = this.getDocument().createRange()\n        range.setStart(sel.anchorNode, startPos)\n        range.setEnd(sel.anchorNode, endPos)\n        range.deleteContents()\n\n        let el = this.getDocument().createElement('div')\n        el.innerHTML = html\n        let frag = this.getDocument().createDocumentFragment(),\n            node, lastNode\n        while ((node = el.firstChild)) {\n            lastNode = frag.appendChild(node)\n        }\n        range.insertNode(frag)\n\n        // Preserve the selection\n        if (lastNode) {\n            range = range.cloneRange()\n            range.setStartAfter(lastNode)\n            range.collapse(true)\n            sel.removeAllRanges()\n            sel.addRange(range)\n        }\n    }\n\n    getWindowSelection() {\n        if (this.tribute.collection.iframe) {\n            return this.tribute.collection.iframe.contentWindow.getSelection()\n        }\n\n        return window.getSelection()\n    }\n\n    getNodePositionInParent(element) {\n        if (element.parentNode === null) {\n            return 0\n        }\n\n        for (var i = 0; i < element.parentNode.childNodes.length; i++) {\n            let node = element.parentNode.childNodes[i]\n\n            if (node === element) {\n                return i\n            }\n        }\n    }\n\n    getContentEditableSelectedPath() {\n        // content editable\n        let sel = this.getWindowSelection()\n        let selected = sel.anchorNode\n        let path = []\n        let offset\n\n        if (selected != null) {\n            let i\n            let ce = selected.contentEditable\n            while (selected !== null && ce !== 'true') {\n                i = this.getNodePositionInParent(selected)\n                path.push(i)\n                selected = selected.parentNode\n                if (selected !== null) {\n                    ce = selected.contentEditable\n                }\n            }\n            path.reverse()\n\n            // getRangeAt may not exist, need alternative\n            offset = sel.getRangeAt(0).startOffset\n\n            return {\n                selected: selected,\n                path: path,\n                offset: offset\n            }\n        }\n    }\n\n    getTextPrecedingCurrentSelection() {\n        let context = this.tribute.current,\n            text\n\n        if (!this.isContentEditable(context.element)) {\n            let textComponent = this.getDocument().activeElement\n            let startPos = textComponent.selectionStart\n            text = textComponent.value.substring(0, startPos)\n\n        }\n        else {\n            let selectedElem = this.getWindowSelection().anchorNode\n\n            if (selectedElem != null) {\n                let workingNodeContent = selectedElem.textContent\n                let selectStartOffset = this.getWindowSelection().getRangeAt(0).startOffset\n\n                if (selectStartOffset >= 0) {\n                    text = workingNodeContent.substring(0, selectStartOffset)\n                }\n            }\n        }\n\n        return text\n    }\n\n    getTriggerInfo(menuAlreadyActive, hasTrailingSpace, requireLeadingSpace) {\n        let ctx = this.tribute.current\n        let selected, path, offset\n\n        if (!this.isContentEditable(ctx.element)) {\n            selected = this.getDocument().activeElement\n        }\n        else {\n            // content editable\n            let selectionInfo = this.getContentEditableSelectedPath()\n\n            if (selectionInfo) {\n                selected = selectionInfo.selected\n                path = selectionInfo.path\n                offset = selectionInfo.offset\n            }\n        }\n\n        let effectiveRange = this.getTextPrecedingCurrentSelection()\n\n        if (effectiveRange !== undefined && effectiveRange !== null) {\n            let mostRecentTriggerCharPos = -1\n            let triggerChar\n\n            this.tribute.triggers().forEach(c => {\n                let idx = effectiveRange.lastIndexOf(c)\n\n                if (idx > mostRecentTriggerCharPos) {\n                    mostRecentTriggerCharPos = idx\n                    triggerChar = c\n                }\n            })\n\n            if (mostRecentTriggerCharPos >= 0 &&\n                (\n                    mostRecentTriggerCharPos === 0 ||\n                    !requireLeadingSpace ||\n                    /[\\xA0\\s]/g.test(\n                        effectiveRange.substring(\n                            mostRecentTriggerCharPos - 1,\n                            mostRecentTriggerCharPos)\n                    )\n                )\n            ) {\n                let currentTriggerSnippet = effectiveRange.substring(mostRecentTriggerCharPos + 1,\n                    effectiveRange.length)\n\n                triggerChar = effectiveRange.substring(mostRecentTriggerCharPos, mostRecentTriggerCharPos + 1)\n                let firstSnippetChar = currentTriggerSnippet.substring(0, 1)\n                let leadingSpace = currentTriggerSnippet.length > 0 &&\n                    (\n                        firstSnippetChar === ' ' ||\n                        firstSnippetChar === '\\xA0'\n                    )\n                if (hasTrailingSpace) {\n                    currentTriggerSnippet = currentTriggerSnippet.trim()\n                }\n                if (!leadingSpace && (menuAlreadyActive || !(/[\\xA0\\s]/g.test(currentTriggerSnippet)))) {\n                    return {\n                        mentionPosition: mostRecentTriggerCharPos,\n                        mentionText: currentTriggerSnippet,\n                        mentionSelectedElement: selected,\n                        mentionSelectedPath: path,\n                        mentionSelectedOffset: offset,\n                        mentionTriggerChar: triggerChar\n                    }\n                }\n            }\n        }\n    }\n\n    isContentEditable(element) {\n        return element.nodeName !== 'INPUT' && element.nodeName !== 'TEXTAREA'\n    }\n\n    getTextAreaOrInputUnderlinePosition(element, position) {\n        let properties = ['direction', 'boxSizing', 'width', 'height', 'overflowX',\n            'overflowY', 'borderTopWidth', 'borderRightWidth',\n            'borderBottomWidth', 'borderLeftWidth', 'paddingTop',\n            'paddingRight', 'paddingBottom', 'paddingLeft',\n            'fontStyle', 'fontVariant', 'fontWeight', 'fontStretch',\n            'fontSize', 'fontSizeAdjust', 'lineHeight', 'fontFamily',\n            'textAlign', 'textTransform', 'textIndent',\n            'textDecoration', 'letterSpacing', 'wordSpacing'\n        ]\n\n        let isFirefox = (window.mozInnerScreenX !== null)\n\n        let div = this.getDocument().createElement('div')\n        div.id = 'input-textarea-caret-position-mirror-div'\n        this.getDocument().body.appendChild(div)\n\n        let style = div.style\n        let computed = window.getComputedStyle ? getComputedStyle(element) : element.currentStyle\n\n        style.whiteSpace = 'pre-wrap'\n        if (element.nodeName !== 'INPUT') {\n            style.wordWrap = 'break-word'\n        }\n\n        // position off-screen\n        style.position = 'absolute'\n        style.visibility = 'hidden'\n\n        // transfer the element's properties to the div\n        properties.forEach(prop => {\n            style[prop] = computed[prop]\n        })\n\n        if (isFirefox) {\n            style.width = `${(parseInt(computed.width) - 2)}px`\n            if (element.scrollHeight > parseInt(computed.height))\n                style.overflowY = 'scroll'\n        }\n        else {\n            style.overflow = 'hidden'\n        }\n\n        div.textContent = element.value.substring(0, position)\n\n        if (element.nodeName === 'INPUT') {\n            div.textContent = div.textContent.replace(/\\s/g, ' ')\n        }\n\n        let span = this.getDocument().createElement('span')\n        span.textContent = element.value.substring(position) || '.'\n        div.appendChild(span)\n\n        let rect = element.getBoundingClientRect()\n        let doc = document.documentElement\n        let windowLeft = (window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0)\n        let windowTop = (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0)\n\n        let coordinates = {\n            top: rect.top + windowTop + span.offsetTop + parseInt(computed.borderTopWidth) + parseInt(computed.fontSize),\n            left: rect.left + windowLeft + span.offsetLeft + parseInt(computed.borderLeftWidth)\n        }\n\n        this.getDocument().body.removeChild(div)\n\n        return coordinates\n    }\n\n    getContentEditableCaretPosition(selectedNodePosition) {\n        let markerTextChar = '﻿'\n        let markerEl, markerId = `sel_${new Date().getTime()}_${Math.random().toString().substr(2)}`\n        let range\n        let sel = this.getWindowSelection()\n        let prevRange = sel.getRangeAt(0)\n\n        range = this.getDocument().createRange()\n        range.setStart(sel.anchorNode, selectedNodePosition)\n        range.setEnd(sel.anchorNode, selectedNodePosition)\n\n        range.collapse(false)\n\n        // Create the marker element containing a single invisible character using DOM methods and insert it\n        markerEl = this.getDocument().createElement('span')\n        markerEl.id = markerId\n        markerEl.appendChild(this.getDocument().createTextNode(markerTextChar))\n        range.insertNode(markerEl)\n        sel.removeAllRanges()\n        sel.addRange(prevRange)\n\n        let rect = markerEl.getBoundingClientRect()\n        let doc = document.documentElement\n        let windowLeft = (window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0)\n        let windowTop = (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0)\n        let coordinates = {\n            left: rect.left + windowLeft,\n            top: rect.top + markerEl.offsetHeight + windowTop\n        }\n\n        markerEl.parentNode.removeChild(markerEl)\n        return coordinates\n    }\n\n    scrollIntoView(elem) {\n        let reasonableBuffer = 20,\n            clientRect\n        let maxScrollDisplacement = 100\n        let e = elem\n\n        while (clientRect === undefined || clientRect.height === 0) {\n            clientRect = e.getBoundingClientRect()\n\n            if (clientRect.height === 0) {\n                e = e.childNodes[0]\n                if (e === undefined || !e.getBoundingClientRect) {\n                    return\n                }\n            }\n        }\n\n        let elemTop = clientRect.top\n        let elemBottom = elemTop + clientRect.height\n\n        if (elemTop < 0) {\n            window.scrollTo(0, window.pageYOffset + clientRect.top - reasonableBuffer)\n        }\n        else if (elemBottom > window.innerHeight) {\n            let maxY = window.pageYOffset + clientRect.top - reasonableBuffer\n\n            if (maxY - window.pageYOffset > maxScrollDisplacement) {\n                maxY = window.pageYOffset + maxScrollDisplacement\n            }\n\n            let targetY = window.pageYOffset - (window.innerHeight - elemBottom)\n\n            if (targetY > maxY) {\n                targetY = maxY\n            }\n\n            window.scrollTo(0, targetY)\n        }\n    }\n}\n\n\nexport default TributeRange;","// Thanks to https://github.com/mattyork/fuzzy\nclass TributeSearch {\n    constructor(tribute) {\n        this.tribute = tribute\n        this.tribute.search = this\n    }\n\n    simpleFilter(pattern, array) {\n        return array.filter(string => {\n            return this.test(pattern, string)\n        })\n    }\n\n    test(pattern, string) {\n        return this.match(pattern, string) !== null\n    }\n\n    match(pattern, string, opts) {\n        opts = opts || {}\n        let patternIdx = 0,\n            result = [],\n            len = string.length,\n            totalScore = 0,\n            currScore = 0,\n            pre = opts.pre || '',\n            post = opts.post || '',\n            compareString = opts.caseSensitive && string || string.toLowerCase(),\n            ch, compareChar\n\n        pattern = opts.caseSensitive && pattern || pattern.toLowerCase()\n\n        let patternCache = this.traverse(compareString, pattern, 0, 0, [])\n        if (!patternCache) {\n            return null\n        }\n\n        return {\n            rendered: this.render(string, patternCache.cache, pre, post),\n            score: patternCache.score\n        }\n    }\n\n    traverse(string, pattern, stringIndex, patternIndex, patternCache) {\n        // if the pattern search at end\n        if (pattern.length === patternIndex) {\n\n            // calculate socre and copy the cache containing the indices where it's found\n            return {\n                score: this.calculateScore(patternCache),\n                cache: patternCache.slice()\n            }\n        }\n\n        // if string at end or remaining pattern > remaining string\n        if (string.length === stringIndex || pattern.length - patternIndex > string.length - stringIndex) {\n            return undefined\n        }\n\n        let c = pattern[patternIndex]\n        let index = string.indexOf(c, stringIndex)\n        let best, temp\n\n        while (index > -1) {\n            patternCache.push(index)\n            temp = this.traverse(string, pattern, index + 1, patternIndex + 1, patternCache)\n            patternCache.pop()\n\n            // if downstream traversal failed, return best answer so far\n            if (!temp) {\n                return best\n            }\n\n            if (!best || best.score < temp.score) {\n                best = temp\n            }\n\n            index = string.indexOf(c, index + 1)\n        }\n\n        return best\n    }\n\n    calculateScore(patternCache) {\n        let score = 0\n        let temp = 1\n\n        patternCache.forEach((index, i) => {\n            if (i > 0) {\n                if (patternCache[i - 1] + 1 === index) {\n                    temp += temp + 1\n                }\n                else {\n                    temp = 1\n                }\n            }\n\n            score += temp\n        })\n\n        return score\n    }\n\n    render(string, indices, pre, post) {\n        var rendered = string.substring(0, indices[0])\n\n        indices.forEach((index, i) => {\n            rendered += pre + string[index] + post +\n                string.substring(index + 1, (indices[i + 1]) ? indices[i + 1] : string.length)\n        })\n\n        return rendered\n    }\n\n    filter(pattern, arr, opts) {\n        opts = opts || {}\n        return arr\n            .reduce((prev, element, idx, arr) => {\n                let str = element\n\n                if (opts.extract) {\n                    str = opts.extract(element)\n\n                    if (!str) { // take care of undefineds / nulls / etc.\n                        str = ''\n                    }\n                }\n\n                let rendered = this.match(pattern, str, opts)\n\n                if (rendered != null) {\n                    prev[prev.length] = {\n                        string: rendered.rendered,\n                        score: rendered.score,\n                        index: idx,\n                        original: element\n                    }\n                }\n\n                return prev\n            }, [])\n\n        .sort((a, b) => {\n            let compare = b.score - a.score\n            if (compare) return compare\n            return a.index - b.index\n        })\n    }\n}\n\nexport default TributeSearch;","if (!Array.prototype.find) {\n    Array.prototype.find = function(predicate) {\n        if (this === null) {\n            throw new TypeError('Array.prototype.find called on null or undefined')\n        }\n        if (typeof predicate !== 'function') {\n            throw new TypeError('predicate must be a function')\n        }\n        var list = Object(this)\n        var length = list.length >>> 0\n        var thisArg = arguments[1]\n        var value\n\n        for (var i = 0; i < length; i++) {\n            value = list[i]\n            if (predicate.call(thisArg, value, i, list)) {\n                return value\n            }\n        }\n        return undefined\n    }\n}\n\n(function() {\n\n    if (typeof window.CustomEvent === \"function\") return false\n\n    function CustomEvent(event, params) {\n        params = params || {\n            bubbles: false,\n            cancelable: false,\n            detail: undefined\n        }\n        var evt = document.createEvent('CustomEvent')\n        evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail)\n        return evt\n    }\n\n    CustomEvent.prototype = window.Event.prototype\n\n    window.CustomEvent = CustomEvent\n})()\n"]} diff --git a/dist/tribute.min.js b/dist/tribute.min.js new file mode 100644 index 00000000..64424002 --- /dev/null +++ b/dist/tribute.min.js @@ -0,0 +1,2 @@ +!function e(t,n,i){function r(u,l){if(!n[u]){if(!t[u]){var a="function"==typeof require&&require;if(!l&&a)return a(u,!0);if(o)return o(u,!0);var c=new Error("Cannot find module '"+u+"'");throw c.code="MODULE_NOT_FOUND",c}var s=n[u]={exports:{}};t[u][0].call(s.exports,function(e){var n=t[u][1][e];return r(n?n:e)},s,s.exports,e,t,n,i)}return n[u].exports}for(var o="function"==typeof require&&require,u=0;u",post:"",extract:function(e){return e[n.current.collection.lookup]}}),this.current.filteredItems=i;var r=this.menu.querySelector("ul");if(!i.length){var o=new CustomEvent("tribute-no-match",{detail:this.menu});return this.current.element.dispatchEvent(o),void(this.current.collection.noMatchTemplate?r.innerHTML=this.current.collection.noMatchTemplate():this.hideMenu())}r.innerHTML="",i.forEach(function(e,t){var i=n.range.getDocument().createElement("li");i.setAttribute("data-index",t),n.menuSelected===t&&(i.className=n.current.collection.selectClass),i.innerHTML=n.current.collection.menuItemTemplate(e),r.appendChild(i)}),this.range.positionMenuAtCaret(t)}},{key:"hideMenu",value:function(){this.menu&&(this.menu.style.cssText="display: none;",this.isActive=!1,this.menuSelected=0,this.current={})}},{key:"selectItemAtIndex",value:function(e){if(e=parseInt(e),"number"==typeof e){var t=this.current.filteredItems[e],n=this.current.collection.selectTemplate(t);this.replaceText(n)}}},{key:"replaceText",value:function(e){this.range.replaceTriggerText(e,!0,!0)}},{key:"_append",value:function(e,t,n,i){this.isActive&&(i?e.values=n:e.values=e.values.concat(n))}},{key:"append",value:function(e,t,n){var i=parseInt(e);if("number"!=typeof i)throw new Error("please provide an index for the collection to update.");this.collection[i];this._append(this.current.collection,this.current.element,t,n)}},{key:"appendCurrent",value:function(e,t){this._append(this.current.collection,this.current.element,e,t)}}],[{key:"defaultSelectTemplate",value:function(e){return"@"+e.original[this.current.collection.fillAttr]}},{key:"defaultMenuItemTemplate",value:function(e){return e.string}},{key:"inputTypes",value:function(){return["TEXTAREA","INPUT"]}}]),e}();t.Tribute=h}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./TributeEvents":2,"./TributeMenuEvents":3,"./TributeRange":4,"./TributeSearch":5,"./utils":6}],2:[function(e,t,n){"use strict";function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}Object.defineProperty(n,"__esModule",{value:!0});var r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol?"symbol":typeof e},o=function(){function e(e,t){for(var n=0;n container for the click");n.selectItemAtIndex(i.getAttribute("data-index")),n.hideMenu()}else n.current.element&&n.hideMenu()}},{key:"keyup",value:function(e,t){var n=this;if(e.inputEvent&&(e.inputEvent=!1),e.updateSelection(this),27!==t.keyCode){if(!e.tribute.isActive){var i=function(){var i=e.getKeyCode(e,n,t);if(isNaN(i))return{v:void 0};var r=e.tribute.triggers().find(function(e){return e.charCodeAt(0)===i});"undefined"!=typeof r&&e.callbacks().triggerChar(t,n,r)}();if("object"===("undefined"==typeof i?"undefined":r(i)))return i.v}(e.tribute.current.trigger&&e.commandEvent===!1||e.tribute.isActive&&8===t.keyCode)&&e.tribute.showMenuFor(this,!0)}}},{key:"shouldDeactivate",value:function(t){if(!this.tribute.isActive)return!1;if(0===this.tribute.current.mentionText.length){var n=!1;return e.keys().forEach(function(e){t.keyCode===e.key&&(n=!0)}),!n}return!1}},{key:"getKeyCode",value:function(e,t,n){var i=e.tribute,r=i.range.getTriggerInfo(!1,!1,!0);return!!r&&r.mentionTriggerChar.charCodeAt(0)}},{key:"updateSelection",value:function(e){this.tribute.current.element=e;var t=this.tribute.range.getTriggerInfo(!1,!1,!0);t&&(this.tribute.current.selectedPath=t.mentionSelectedPath,this.tribute.current.mentionText=t.mentionText,this.tribute.current.selectedOffset=t.mentionSelectedOffset)}},{key:"callbacks",value:function(){var e=this;return{triggerChar:function(t,n,i){var r=e.tribute;r.current.trigger=i;var o=r.collection.find(function(e){return e.trigger===i});r.current.collection=o,r.showMenuFor(n,!0)},enter:function(t,n){e.tribute.isActive&&(t.preventDefault(),setTimeout(function(){e.tribute.selectItemAtIndex(e.tribute.menuSelected),e.tribute.hideMenu()},0))},escape:function(t,n){e.tribute.isActive&&(t.preventDefault(),e.tribute.hideMenu())},tab:function(t,n){e.callbacks().enter(t,n)},up:function(t,n){if(e.tribute.isActive){t.preventDefault();var i=e.tribute.current.filteredItems.length,r=e.tribute.menuSelected;i>r&&r>0&&(e.tribute.menuSelected--,e.setActiveLi())}},down:function(t,n){if(e.tribute.isActive){t.preventDefault();var i=e.tribute.current.filteredItems.length-1,r=e.tribute.menuSelected;i>r&&(e.tribute.menuSelected++,e.setActiveLi())}},delete:function(t,n){e.tribute.isActive&&e.tribute.current.mentionText.length<1?e.tribute.hideMenu():e.tribute.isActive&&tribute.showMenuFor(n)}}}},{key:"setActiveLi",value:function(e){for(var t=this.tribute.menu.querySelectorAll("li"),n=t.length>>>0,i=0;i=0&&(t=i.substring(0,r))}}else{var o=this.getDocument().activeElement,u=o.selectionStart;t=o.value.substring(0,u)}return t}},{key:"getTriggerInfo",value:function(e,t,n){var i=this,o=this.tribute.current,u=void 0,l=void 0,a=void 0;if(this.isContentEditable(o.element)){var c=this.getContentEditableSelectedPath();c&&(u=c.selected,l=c.path,a=c.offset)}else u=this.getDocument().activeElement;var s=this.getTextPrecedingCurrentSelection();if(void 0!==s&&null!==s){var d=function(){var r=-1,o=void 0;if(i.tribute.triggers().forEach(function(e){var t=s.lastIndexOf(e);t>r&&(r=t,o=e)}),r>=0&&(0===r||!n||/[\xA0\s]/g.test(s.substring(r-1,r)))){var c=s.substring(r+1,s.length);o=s.substring(r,r+1);var d=c.substring(0,1),f=c.length>0&&(" "===d||" "===d);if(t&&(c=c.trim()),!f&&(e||!/[\xA0\s]/g.test(c)))return{v:{mentionPosition:r,mentionText:c,mentionSelectedElement:u,mentionSelectedPath:l,mentionSelectedOffset:a,mentionTriggerChar:o}}}}();if("object"===("undefined"==typeof d?"undefined":r(d)))return d.v}}},{key:"isContentEditable",value:function(e){return"INPUT"!==e.nodeName&&"TEXTAREA"!==e.nodeName}},{key:"getTextAreaOrInputUnderlinePosition",value:function(e,t){var n=["direction","boxSizing","width","height","overflowX","overflowY","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","paddingTop","paddingRight","paddingBottom","paddingLeft","fontStyle","fontVariant","fontWeight","fontStretch","fontSize","fontSizeAdjust","lineHeight","fontFamily","textAlign","textTransform","textIndent","textDecoration","letterSpacing","wordSpacing"],i=null!==window.mozInnerScreenX,r=this.getDocument().createElement("div");r.id="input-textarea-caret-position-mirror-div",this.getDocument().body.appendChild(r);var o=r.style,u=window.getComputedStyle?getComputedStyle(e):e.currentStyle;o.whiteSpace="pre-wrap","INPUT"!==e.nodeName&&(o.wordWrap="break-word"),o.position="absolute",o.visibility="hidden",n.forEach(function(e){o[e]=u[e]}),i?(o.width=parseInt(u.width)-2+"px",e.scrollHeight>parseInt(u.height)&&(o.overflowY="scroll")):o.overflow="hidden",r.textContent=e.value.substring(0,t),"INPUT"===e.nodeName&&(r.textContent=r.textContent.replace(/\s/g," "));var l=this.getDocument().createElement("span");l.textContent=e.value.substring(t)||".",r.appendChild(l);var a=e.getBoundingClientRect(),c=document.documentElement,s=(window.pageXOffset||c.scrollLeft)-(c.clientLeft||0),d=(window.pageYOffset||c.scrollTop)-(c.clientTop||0),f={top:a.top+d+l.offsetTop+parseInt(u.borderTopWidth)+parseInt(u.fontSize),left:a.left+s+l.offsetLeft+parseInt(u.borderLeftWidth)};return this.getDocument().body.removeChild(r),f}},{key:"getContentEditableCaretPosition",value:function(e){var t="\ufeff",n=void 0,i="sel_"+(new Date).getTime()+"_"+Math.random().toString().substr(2),r=void 0,o=this.getWindowSelection(),u=o.getRangeAt(0);r=this.getDocument().createRange(),r.setStart(o.anchorNode,e),r.setEnd(o.anchorNode,e),r.collapse(!1),n=this.getDocument().createElement("span"),n.id=i,n.appendChild(this.getDocument().createTextNode(t)),r.insertNode(n),o.removeAllRanges(),o.addRange(u);var l=n.getBoundingClientRect(),a=document.documentElement,c=(window.pageXOffset||a.scrollLeft)-(a.clientLeft||0),s=(window.pageYOffset||a.scrollTop)-(a.clientTop||0),d={left:l.left+c,top:l.top+n.offsetHeight+s};return n.parentNode.removeChild(n),d}},{key:"scrollIntoView",value:function(e){for(var t=20,n=void 0,i=100,r=e;void 0===n||0===n.height;)if(n=r.getBoundingClientRect(),0===n.height&&(r=r.childNodes[0],void 0===r||!r.getBoundingClientRect))return;var o=n.top,u=o+n.height;if(o<0)window.scrollTo(0,window.pageYOffset+n.top-t);else if(u>window.innerHeight){var l=window.pageYOffset+n.top-t;l-window.pageYOffset>i&&(l=window.pageYOffset+i);var a=window.pageYOffset-(window.innerHeight-u);a>l&&(a=l),window.scrollTo(0,a)}}}]),e}();n.default=u},{}],5:[function(e,t,n){"use strict";function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}Object.defineProperty(n,"__esModule",{value:!0});var r=function(){function e(e,t){for(var n=0;ne.length-n)){for(var o=t[i],u=e.indexOf(o,n),l=void 0,a=void 0;u>-1;){if(r.push(u),a=this.traverse(e,t,u+1,i+1,r),r.pop(),!a)return l;(!l||l.score0&&(e[r-1]+1===i?n+=n+1:n=1),t+=n}),t}},{key:"render",value:function(e,t,n,i){var r=e.substring(0,t[0]);return t.forEach(function(o,u){r+=n+e[o]+i+e.substring(o+1,t[u+1]?t[u+1]:e.length)}),r}},{key:"filter",value:function(e,t,n){var i=this;return n=n||{},t.reduce(function(t,r,o,u){var l=r;n.extract&&(l=n.extract(r),l||(l=""));var a=i.match(e,l,n);return null!=a&&(t[t.length]={string:a.rendered,score:a.score,index:o,original:r}),t},[]).sort(function(e,t){var n=t.score-e.score;return n?n:e.index-t.index})}}]),e}();n.default=o},{}],6:[function(e,t,n){"use strict";Array.prototype.find||(Array.prototype.find=function(e){if(null===this)throw new TypeError("Array.prototype.find called on null or undefined");if("function"!=typeof e)throw new TypeError("predicate must be a function");for(var t,n=Object(this),i=n.length>>>0,r=arguments[1],o=0;o